标签: executorservice

所以我有一个程序产生线程(~5-150)执行一堆任务.最初我使用的是FixedThreadPool因为这个类似的问题表明它们更适合长寿命的任务,而且由于我对多线程的知识非常有限,我认为线程的平均寿命(几分钟)" 长寿 ".

但是,我最近添加了生成其他线程的功能,这样做超过了我设置的线程限制.在这种情况下,最好猜测并增加我可以允许的线程数或切换到一个CachedThreadPool所以我没有浪费线程？

初步尝试它们,似乎没有什么区别,所以我倾向于选择CachedThreadPool公正以避免浪费.但是,线程的生命周期是否意味着我应该选择一个FixedThreadPool并且只处理未使用的线程？这个问题使得看起来这些额外的线程没有浪费,但我希望澄清.

ExecutorService保证是否安全？

我将从不同的线程向同一个ThreadPoolExecutor提交作业,在交互/提交任务之前是否必须同步对执行程序的访问？

我正在尝试编写一个解决方案,其中单个线程生成可以并行执行的I/O密集型任务.每个任务都有重要的内存数据.所以我希望能够限制暂时待处理的任务数量.

如果我像这样创建ThreadPoolExecutor:

    ThreadPoolExecutor executor = new ThreadPoolExecutor(numWorkerThreads, numWorkerThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>(maxQueue));

然后在队列填满并且所有线程都已忙时executor.submit(callable)抛出RejectedExecutionException.

executor.submit(callable)当队列已满且所有线程都忙时,我该怎么做才能阻塞？

编辑:我试过这个:

executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

它有点实现了我想要实现的效果但是以一种不雅的方式(基本上被拒绝的线程在调用线程中运行,因此这阻止了调用线程提交更多).

编辑:(提问后5年)

对于阅读此问题及其答案的任何人,请不要将接受的答案作为一个正确的解决方案.请仔细阅读所有答案和评论.

在过去的几个小时里,我正在阅读相当多shutdown()的内容ExecutorService,除非我们有一个庞大的应用程序存储,几十个和几十个不使用的不同的执行程序服务,我根本看不出有任何理由(有正当理由).很长时间.

关闭所做的唯一事情(从我收集的内容)是正常线程完成后所做的事情.当普通的Thread完成Runnable(或Callable)的run方法时,它将被传递给Garbage Collection进行收集.使用Executor Service,线程将被暂停,不会为垃圾收集打勾.为此,需要关机.

好的,回到我的问题.是否有任何理由ExecutorService经常或甚至在提交一些任务后立即调用关机？我想留下有人正在做的情况,并在调用之后,awaitTermination()因为这是有效的.一旦我们这样做,我们必须重新创建一个新的ExecutorService,做同样的事情.是不是ExecutorService重用线程的整个想法？那么为什么要ExecutorService这么快就毁灭呢？

简单地创建ExecutorService(或依赖于你需要的数量)是不是一种合理的方式,然后在应用程序运行期间,一旦它们出现就将任务传递给它们,然后在应用程序出口或其他一些重要阶段关闭那些执行程序？

我想从一些经验丰富的编码员那里回答,他们使用ExecutorServices写了很多异步代码.

第二个问题,与平台有点小的交易.如果你们中的一些人会说每次关闭执行程序并不是最好的想法,并且你在android上编程,你能不能告诉我当你处理不同的事件时你如何处理这些关闭(具体来说 - 当你执行它们时)应用生命周期.

由于CommonsWare的评论我发布了中立的帖子.我真的没有兴趣争论死亡,似乎它在那里领先.如果他们愿意分享他们的经验,我只对从经验丰富的开发者那里了解我的问题感兴趣.谢谢.

我在Java 1.6中使用ExecutoreService,简单地开始

ExecutorService pool = Executors.newFixedThreadPool(THREADS). 

当我的主线程完成时(以及线程池处理的所有任务),此池将阻止我的程序关闭,直到我显式调用

pool.shutdown();

我可以避免不得不通过某种方式将此池使用的内部线程管理变为deamon线程来调用它吗？或者我在这里遗漏了一些东西.

当使用ExecutorService和Future对象(提交Runnable任务时)时,如果我为未来的get函数指定了超时值,那么在TimeoutException抛出a时底层线程是否会被杀死？

在将此标记为重复之前,请仔细阅读该问题.

下面是伪代码的片段.我的问题是 - 以下代码是否没有打败并行异步处理的概念？

我问这个的原因是因为在下面的代码中,主线程将提交一个要在不同线程中执行的任务.在队列中提交任务后,它会阻止Future.get()方法为任务返回值.我宁愿在主线程中执行任务,而不是提交到不同的线程并等待结果.通过在新线程中执行任务我获得了什么？

我知道你可以等待有限的时间等,但如果我真的关心结果呢？如果要执行多个任务,问题会变得更糟.在我看来,我们只是同步地完成工作.我知道Guava库提供了非阻塞侦听器接口.但我很想知道我对Future.get()API的理解是否正确.如果它是正确的,为什么Future.get()设计为阻止从而打败整个并行处理过程？

注 - 为了记录,我使用JAVA 6

public static void main(String[] args){

private ExectorService executorService = ...

Future future = executorService.submit(new Callable(){
    public Object call() throws Exception {
        System.out.println("Asynchronous Callable");
        return "Callable Result";
    }
});

System.out.println("future.get() = " + future.get());
}

我试图使用ThreadPoolExecutor执行许多任务.以下是一个假设的例子:

def workQueue = new ArrayBlockingQueue<Runnable>(3, false)
def threadPoolExecutor = new ThreadPoolExecutor(3, 3, 1L, TimeUnit.HOURS, workQueue)
for(int i = 0; i < 100000; i++)
    threadPoolExecutor.execute(runnable)

问题是我很快得到了java.util.concurrent.RejectedExecutionException,因为任务数量超过了工作队列的大小.但是,我正在寻找的所需行为是让主线程阻塞,直到队列中有空间.完成此任务的最佳方法是什么？

我正在学习用来ExectorService汇集threads和发送任务.我有一个简单的程序如下

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;


class Processor implements Runnable {

    private int id;

    public Processor(int id) {
        this.id = id;
    }

    public void run() {
        System.out.println("Starting: " + id);

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            System.out.println("sorry, being interupted, good bye!");
            System.out.println("Interrupted "+Thread.currentThread().getName());
            e.printStackTrace();    
        }

        System.out.println("Completed: " + id);
    }
}


public class ExecutorExample {

    public static void main(String[] args) {
        Boolean isCompleted=false;

        ExecutorService executor = Executors.newFixedThreadPool(2);

        for(int i=0; i<5; i++) {
            executor.execute(new …

我刚读完这篇文章:Java-5 ThreadPoolExecutor相对于Java-7 ForkJoinPool有什么优势？觉得答案不够直接.

您能用简单的语言和示例来解释,Java 7的Fork-Join框架与旧解决方案之间的权衡取舍是什么？

我还阅读了Google关于Java提示的#1热门提示:何时从javaworld.com 使用ForkJoinPool vs ExecutorService但文章没有回答标题问题时,它主要讨论api差异......