标签: threadpoolexecutor

这对我来说是最令人困惑的话题之一。所以我的问题是，完成后传达后台线程结果的正确方法是什么？.

想象一下，我想TextView用我刚刚下载的一些信息更新一些信息。当我需要执行后台任务时，我使用了 3 样东西：

异步任务

非常容易使用，这个onPostExecute()方法有将结果直接返回给 UiThread的方法，这样我就可以使用回调接口或做任何我想做的事情。我喜欢这门课，但它已被弃用。

线程池执行器

这就是我在需要执行后台任务时实际使用的方法，而我的问题就出现在我必须将结果提供给 UiThread 的那一刻。我自己了解Looper和Handler类以及有关mainLooper。

所以，当我需要返回一些结果时，我使用的方法runOnUiThread()，正如我所读到的，只是获取LooperUi 线程的 并将我Runnable的发布到队列中。

嗯，这是有效的，我可以与主线程通信，但是，我发现它真的很难看，而且我确信有一种比填充我所有的“ runOnUiThread()”方法代码更优雅的方法。此外，如果后台任务需要太多时间，也许用户已经更改Activity或Fragment当内部代码runOnUiThread()运行时会导致什么Exceptions（我知道使用LiveData和MVVM模式可以解决最后一个问题，但我在一个遗留项目中工作，我不能重构所有代码，以便我使用经典的 Activity mvc 模式）

那么，还有另一种方法吗？你能举个例子吗？我真的搜索了很多，但没有找到任何东西......

协程

我实际上在一个遗留项目中工作，我必须使用 Java，所以不能使用 Kotlin coroutines，但我发现它们易于使用且功能强大。

任何帮助，将不胜感激！

我们有一个场景,提交给ThreadPoolExecutor的任务是长期运行的.当线程池启动时,我们启动它,核心池大小= 5,最大池大小= 20,队列大小为10.在我们的应用程序中,大约有10个任务被提交.大多数情况下,这些任务运行几分钟/小时然后完成.然而,有一种情况是所有5个任务都被I/O挂起.结果我的核心池大小达到了最大值,但我的Threadpoolexecutor队列未满.所以额外的5个任务永远不会有机会运行.请建议我们如何处理这种情况？在这种情况下,有一个更小的队列更好的选择吗？初始化threadPool时最佳队列大小是多少？

关于被绞死的任务,有什么方法可以将线程从Threadpool中拉出来？在这种情况下,至少其他任务将有机会运行.

我必须在Android的一个组件中使用Java ThreadPoolExecutor.我正在搜索allowCoreThreadTimeout()的使用.

我已经阅读了相关的Java和Android文档.但是我没有得到任何有用的方法实现方案.有人可以帮帮我吗？？

我想进入春季多线程,我几乎没有问题.

我在ThreadRating类中有runnable方法.现在我不确定使用它的最佳方式.

选项1我发现:

private void updateRating() {
        ExecutorService executor = Executors.newFixedThreadPool(10);

    for (int i = 0; i < 10; i++) { // test
        // thread part
        Runnable worker = new ThreadRating(path, i, products.get(i), dao, fileHandler);
        executor.execute(worker);
    }
    executor.shutdown();
    try {
        executor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
    } catch (InterruptedException e) {
        log.error("There was an error when ending threads");
        System.exit(1);
    }
    System.out.println("Finished all threads");
}

这似乎运行良好.在for循环之后,它等待直到线程完成并结束.

我试过第二个选项

private TaskExecutor taskExecutor;

public UpdateBO(TaskExecutor taskExecutor) {
    this.taskExecutor = taskExecutor;
}

private void updateRating() {
        for (int i …

我正在对Spring应用程序进行一些负载测试,现在我对它的配置有点困惑ThreadPoolTaskExecutor.

内部使用的文档ThreadPoolExecutor描述corePoolSize为"要保留在池中的线​​程数,即使它们是空闲的,[...]"和maximumPoolSize"池中允许的最大线程数".

这显然意味着maximumPoolSize限制池中线程的数量.但相反,限制似乎是由corePoolSize.实际上我配置只是corePoolSize与100一个让maximumPoolSize未配置(这意味着使用默认值:Integer.MAX_VALUE= 2147483647).

当我运行负载测试,我可以看到(通过查看日志),为所进行的工作线程从编号worker-1来worker-100.所以在这种情况下,线程池大小受限于corePoolSize.即使我设置maximumPoolSize为200或300,结果也完全一样.

为什么价值对maximumPoolSize我的情况没有影响？

@Bean
public TaskExecutor taskExecutor() {
    ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
    taskExecutor.setCorePoolSize(100);
    taskExecutor.setThreadNamePrefix("worker-");
    return taskExecutor;
}

解

我在文档中找到了解决方案:" 如果运行的corePoolSize不止于maxPoolSize,但只有队列已满,才会创建新线程 ".默认队列大小是Integer.MAX_VALUE.如果我限制队列,一切正常.

我想处理ThreadPoolExecutor#afterExecute()方法中工作线程抛出的exeptions .目前我有这个代码:

public class MyExecutor extends ThreadPoolExecutor {

    public static void main(String[] args) {
        MyExecutor threadPool = new MyExecutor();
        Task<Object> task = new Task<>();
        threadPool.submit(task);
    }

    public MyExecutor() {
        super(4, 20, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<>(4000));
    }

    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);
        System.out.println("in afterExecute()");
        if (t != null) {
            System.out.println("exception thrown: " + t.getMessage());
        } else {
            System.out.println("t == null");
        }
    }

    private static class Task<V> implements Callable<V> {

        @Override
        public V call() throws …

我离开应用程序一段时间后,我的logcat中出现了这些警告.(虽然没有杀死,只是按回来离开它.)

05-03 13:43:42.955 13047-13053/package W/art: Suspending all threads took: 7.873ms
05-03 13:44:32.458 13047-13053/package W/art: Suspending all threads took: 13.441ms
05-03 13:46:58.584 13047-13053/package W/art: Suspending all threads took: 34.462ms
05-03 13:47:00.574 13047-13053/package W/art: Suspending all threads took: 8.281ms
05-03 13:48:00.425 13047-13053/package W/art: Suspending all threads took: 25.929ms
05-03 13:48:16.019 13047-13053/package W/art: Suspending all threads took: 35.053ms
05-03 13:50:01.858 13047-13053/package W/art: Suspending all threads took: 16.160ms
05-03 13:50:17.975 13047-13053/package W/art: Suspending all threads took: 20.074ms
05-03 13:52:07.744 13047-13053/package W/art: Suspending all threads …

我正在尝试使用以下属性构建一个实现ExecutorService,让我们调用它SequentialPooledExecutor.

1. SequentialPooledExecutor共享相同线程池的所有实例

2. 对相同实例的调用SequentialPooledExecutor按顺序执行.

换句话说,实例在开始处理其队列中的下一个任务之前等待当前正在执行的任务的终止.

我目前正在实施SequentialPooledExecutor自己,但我想知道我是否正在重新发明轮子.我研究了不同的实现ExecutorService,例如那些由Executors类提供的实现,但我找不到符合我要求的实现.

你知道我现有的实现是否缺失,还是我应该继续自己实现界面？

编辑:

我认为我的要求不是很清楚,让我们看看我是否可以用其他的话来解释它.

假设我有一系列会话,比如1000个(我以前称之为执行程序实例的东西).我可以向会话提交任务,我希望保证提交给同一会话的所有任务都按顺序执行.但是,属于不同会话的任务应该彼此没有依赖关系.

我想定义一个ExecutorService执行这些任务但是使用有限数量的线程,比方说200,但确保在同一个会话中的前一个任务完成之前没有启动任务.

我不知道是否存在已经存在的任何事情,或者我是否应该实施这样的ExecutorService事情.

我想使用 python ThreadPoolExecutor （附加代码）同时调用两个 api。如果这两个 api 调用中的任何一个有响应，我想停止调用另一个。因为对于我的用例，两个 api 之一将需要很长时间才能返回响应，我想避免调用。

def get_rest_api_response(url):
    return requets.get(url)
    
import requests, os
import concurrent.futures
from concurrent.futures import ThreadPoolExecutor, as_completed
with ThreadPoolExecutor(max_workers=4) as executor:
    f1 = executor.submit(get_rest_api_response, url="REST_API_URL_1")
    f2 = executor.submit(get_rest_api_response, url="REST_API_URL_2")
    
    no_future_is_done = True
    while(no_future_is_done):
        if f1.done():
            no_future_is_done = False
            print("f1 is done")
            output = f1.result()
            print(f2.cancel())  ######------> Failing!
        if f2.done():
            no_future_is_done = False
            print("f2 is done")
            output = f2.result()
            print(f1.cancel()) ######-------> Failing!
    print(output)

我正在使用 future.cancel() 但它失败并返回 False。 https://pd.codechef.com/docs/py/3.4.2/library/concurrent.futures.html#concurrent.futures.Future.cancel

我还有其他方法可以实现这一目标吗？

我创建了一个注释,用于创建使用环境中的值填充的ThreadPoolTask​​Executors.但是,当我自动装配bean时,它给了我一个代理并调用代理上的方法给出了错误的值.

如果我手动访问目标类,那么我得到正确的值.

Executor exec = (Executor) ((Advised) executor).getTargetSource().getTarget();
ThreadPoolTaskExecutor taskExec = (ThreadPoolTaskExecutor) exec;

我一直在摸不着头脑,为什么我得到了一个代理bean,但似乎无法弄明白.

我正在使用注释导入我的注册器类,该类实现ImportBeanDefinitionRegistrar来注册bean.注册商代码如下:

public class ExecutorEnumerationRegistrar implements ImportBeanDefinitionRegistrar, EnvironmentAware {

    public static final String CORE_POOL_SIZE = "corePoolSize";
    public static final String MAX_POOL_SIZE = "maxPoolSize";
    public static final String QUEUE_CAPACITY = "queueCapacity";
    public static final String THREAD_NAME_PREFIX = "threadNamePrefix";
    private static final String REJECTED_EXECUTION_HANDLER = "rejectedExecutionHandler";
    private static final String NAMES = "names";
    private static final String REJECTED_HANDLER = "rejectedHandler";
    private Environment env;

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry …