ExecutorService与Casual Thread Spawner

Question

我有一个关于如何ExecutorService在Java中工作的基本问题.

很难看出简单地创建Threads并行执行某些任务和将每个任务分配给它们之间的区别ThreadPool.

使用起来ExecutorService也非常简单和有效,所以我想知道为什么我们不一直使用它.

这只是一种比另一种方式更快地执行其工作的问题吗？

这里有两个非常简单的例子来说明两种方式之间的区别:

使用执行程序服务:Hello World(任务)

static class HelloTask implements Runnable {
    String msg;

    public HelloTask(String msg) {
        this.msg = msg; 
    }
    public void run() {
        long id = Thread.currentThread().getId();
        System.out.println(msg + " from thread:" + id);
    }
}

使用执行程序服务:Hello World(创建执行程序,提交)

static class HelloTask {
    public static void main(String[] args) {
        int ntasks = 1000;
        ExecutorService exs = Executors.newFixedThreadPool(4);

        for (int i=0; i<ntasks; i++) { 
            HelloTask t = new HelloTask("Hello from task " + i);    
            exs.submit(t);
        }
        exs.shutdown();
    }
}

---

下面是一个类似的例子,但是扩展了Callable接口,你能告诉我两者之间的区别吗？在哪种情况下,应该使用特定的一个而不是另一个？

使用执行程序服务:计数器(任务)

static class HelloTaskRet implements Callable<Long> {
    String msg;

    public HelloTaskRet(String msg) {
        this.msg = msg; }

        public Long call() {
        long tid = Thread.currentThread().getId(); 
        System.out.println(msg + " from thread:" + tid); 
        return tid;
    } 
}

使用执行程序服务:(创建,提交)

static class HelloTaskRet {
    public static void main(String[] args) {
        int ntasks = 1000;
        ExecutorService exs = Executors.newFixedThreadPool(4);

        Future<Long>[] futures = (Future<Long>[]) new Future[ntasks];

        for (int i=0; i<ntasks; i++) { 
            HelloTaskRet t = new HelloTaskRet("Hello from task " + i);
            futures[i] = exs.submit(t);
        }
        exs.shutdown();
    }
}

Answer 1

虽然问题和示例代码没有关联,但我会尝试澄清两者.ExecutorService过度随意产生线程的优点是它的行为可预测并避免了线程创建的开销,这在JVM上相对较大(例如,它需要为每个线程保留内存).通过可预测性,至少对于fixedThreadPool我来说,我的意思是你知道并发线程的最大数量,并且你知道它们何时以及如何被创建(因此你的JVM在突然出现峰值的情况下不会爆炸).

作者Vince Emigh: ExecutorService也支持cachedThreadPool,没有最大值.人们选择使用的主要原因ExecutorService是为了防止创建多个线程的开销(通过使用工作线程).它主要用于需要在单独的线程上执行许多小任务的情况.另外,别忘了 singleThreadExecutor.

现在,关于Runnablevs 的主题,Callable从您的示例中很容易看出.Callables可以返回一个值占位符(Future),最终将由实际值填充.Runnables不能退货.

作者:Vince Emigh: Runnable也不能抛出异常Callable.

Answer 2

与普通线程相比,ExecutorService提供了许多优势

1. 您可以创建/管理/控制线程的生命周期并优化线程创建成本开销
2. 您可以控制任务的处理(工作窃取,ForkJoinPool,invokeAll)等.
3. 您可以在将来的时间安排任务
4. 您可以监视线程的进度和运行状况

即使对于单个线程,我也喜欢使用 Executors.newFixedThreadPool(1);

看看相关的SE问题:

Java的Fork/Join vs ExecutorService - 何时使用哪个？

使用ExecutorService有什么好处？