Chuyển một ExecutorService thành daemon trong Java

Tôi đang sử dụng ExecutoreService trong Java 1.6, bắt đầu đơn giản bằng

ExecutorService pool = Executors.newFixedThreadPool(THREADS). 

Khi luồng chính của tôi kết thúc (cùng với tất cả các tác vụ được xử lý bởi nhóm luồng), nhóm này sẽ ngăn chương trình của tôi tắt cho đến khi tôi gọi rõ ràng

pool.shutdown();

Tôi có thể tránh phải gọi điều này bằng cách nào đó chuyển quản lý luồng nội bộ được sử dụng bởi nhóm này thành một luồng ngừng hoạt động không? Hoặc tôi đang thiếu một cái gì đó ở đây.

Có lẽ giải pháp đơn giản nhất và được ưu tiên là câu trả lời của Marco13, vì vậy đừng để bị lừa bởi sự khác biệt về phiếu bầu (câu trả lời của tôi cũ hơn vài năm) hoặc dấu chấp nhận (nó chỉ có nghĩa là giải pháp của tôi phù hợp với hoàn cảnh OP chứ không phải là tốt nhất).

Bạn có thể sử dụng ThreadFactoryđể đặt các luồng bên trong Executor thành daemon. Điều này sẽ ảnh hưởng đến dịch vụ thực thi theo cách mà nó cũng sẽ trở thành luồng daemon nên nó (và các luồng được xử lý bởi nó) sẽ dừng nếu không có luồng không phải là daemon nào khác. Đây là ví dụ đơn giản:

ExecutorService exec = Executors.newFixedThreadPool(4,
        new ThreadFactory() {
            public Thread newThread(Runnable r) {
                Thread t = Executors.defaultThreadFactory().newThread(r);
                t.setDaemon(true);
                return t;
            }
        });

exec.execute(YourTaskNowWillBeDaemon);

Nhưng nếu bạn muốn nhận trình thực thi sẽ cho phép tác vụ của nó kết thúc và đồng thời sẽ tự động gọi shutdown()phương thức của nó khi ứng dụng hoàn tất, bạn có thể muốn bọc trình thực thi của mình bằng Guava MoreExecutors.getExitingExecutorService .

ExecutorService exec = MoreExecutors.getExitingExecutorService(
        (ThreadPoolExecutor) Executors.newFixedThreadPool(4), 
        100_000, TimeUnit.DAYS//period after which executor will be automatically closed
                             //I assume that 100_000 days is enough to simulate infinity
);
//exec.execute(YourTask);
exec.execute(() -> {
    for (int i = 0; i < 3; i++) {
        System.out.println("daemon");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
});

Đã có một chức năng tích hợp để tạo một ExecutorServicekết thúc tất cả các chuỗi sau một thời gian không hoạt động nhất định: Bạn có thể tạo một ThreadPoolExecutor, chuyển cho nó thông tin thời gian mong muốn, sau đó gọi allowCoreThreadTimeout(true)dịch vụ thực thi này:

/**
 * Creates an executor service with a fixed pool size, that will time 
 * out after a certain period of inactivity.
 * 
 * @param poolSize The core- and maximum pool size
 * @param keepAliveTime The keep alive time
 * @param timeUnit The time unit
 * @return The executor service
 */
public static ExecutorService createFixedTimeoutExecutorService(
    int poolSize, long keepAliveTime, TimeUnit timeUnit)
{
    ThreadPoolExecutor e = 
        new ThreadPoolExecutor(poolSize, poolSize,
            keepAliveTime, timeUnit, new LinkedBlockingQueue<Runnable>());
    e.allowCoreThreadTimeOut(true);
    return e;
}

CHỈNH SỬA Tham khảo các chú thích trong nhận xét: Lưu ý rằng trình thực thi nhóm luồng này sẽ không tự động tắt khi ứng dụng thoát. Trình thực thi sẽ tiếp tục chạy sau khi ứng dụng thoát, nhưng không lâu hơn keepAliveTime. Nếu, tùy thuộc vào các yêu cầu ứng dụng chính xác, keepAliveTimephải dài hơn vài giây, thì giải pháp trong câu trả lời của Pshemo có thể phù hợp hơn: Khi các chủ đề được đặt thành các chủ đề daemon, thì chúng sẽ kết thúc ngay lập tức khi ứng dụng thoát .

Tôi sẽ sử dụng lớp ThreadFactoryBuilder của Guava.

ExecutorService threadPool = Executors.newFixedThreadPool(THREADS, new ThreadFactoryBuilder().setDaemon(true).build());

Nếu bạn chưa sử dụng Guava, tôi sẽ sử dụng lớp con ThreadFactory như được mô tả ở đầu câu trả lời của Pshemo

Nếu bạn chỉ muốn sử dụng nó ở một nơi, thì bạn có thể nội dòng java.util.concurrent.ThreadFactorytriển khai, ví dụ: đối với một nhóm có 4 luồng bạn sẽ viết (ví dụ được hiển thị dưới dạng lambda giả sử Java 1.8 hoặc mới hơn):

ExecutorService pool = Executors.newFixedThreadPool(4,
        (Runnable r) -> {
            Thread t = new Thread(r);
            t.setDaemon(true);
            return t;
        }
);

Nhưng tôi thường muốn tất cả các nhà máy Thread của mình tạo ra các luồng daemon, vì vậy tôi thêm một lớp tiện ích như sau:

import java.util.concurrent.ThreadFactory;

public class DaemonThreadFactory implements ThreadFactory {

    public final static ThreadFactory instance = 
                    new DaemonThreadFactory();

    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r);
        t.setDaemon(true);
        return t;
    }
}

Điều đó cho phép tôi dễ dàng chuyển DaemonThreadFactory.instanceđến ExecutorService, ví dụ:

ExecutorService pool = Executors.newFixedThreadPool(
    4, DaemonThreadFactory.instance
);

hoặc sử dụng nó để dễ dàng bắt đầu một Thread daemon từ một Runnable, ví dụ:

DaemonThreadFactory.instance.newThread(
    () -> { doSomething(); }
).start();

Đúng.

Bạn chỉ cần tạo một ThreadFactorylớp của riêng mình để tạo các luồng daemon thay vì các luồng thông thường.

Giải pháp này tương tự như @ Marco13 của nhưng thay vì tạo ThreadPoolExecutor , chúng ta có thể sửa đổi giải pháp được trả về Executors#newFixedThreadPool(int nThreads). Đây là cách thực hiện:

ExecutorService ex = Executors.newFixedThreadPool(nThreads);
 if(ex instanceof ThreadPoolExecutor){
    ThreadPoolExecutor tp = (ThreadPoolExecutor) ex;
    tp.setKeepAliveTime(time, timeUnit);
    tp.allowCoreThreadTimeOut(true);
}

Bạn có thể sử dụng ThreadFactoryBuilder của Guava. Tôi không muốn thêm phần phụ thuộc và tôi muốn chức năng từ Executor.DefaultThreadFactory, vì vậy tôi đã sử dụng thành phần:

class DaemonThreadFactory implements ThreadFactory {
    final ThreadFactory delegate;

    DaemonThreadFactory() {
        this(Executors.defaultThreadFactory());
    }

    DaemonThreadFactory(ThreadFactory delegate) {
        this.delegate = delegate;
    }

    @Override
    public Thread newThread(Runnable r) {
        Thread thread = delegate.newThread(r);
        thread.setDaemon(true);
        return thread;
    }
}

Nếu bạn có một danh sách các nhiệm vụ đã biết, bạn không cần các luồng daemon. Bạn có thể chỉ cần gọi shutdown () trên ExecutorService sau khi gửi tất cả các nhiệm vụ của mình.

Khi luồng chính của bạn hoàn tất, hãy sử dụng phương thức awaitTermination () để cho phép thời gian hoàn thành các tác vụ đã gửi. Các tác vụ đã gửi hiện tại sẽ được thực thi và nhóm luồng sẽ chấm dứt luồng điều khiển sau khi chúng đã hoàn thành.

for (Runnable task : tasks) {
  threadPool.submit(task);
}
threadPool.shutdown();
/*... do other stuff ...*/
//All done, ready to exit
while (!threadPool.isTerminated()) {
  //this can throw InterruptedException, you'll need to decide how to deal with that.
  threadPool.awaitTermination(1,TimeUnit.SECOND); 
}