Java ThreadPool重用runnable对象，而不是为每个任务创建新对象
Java ThreadPool是Java中用于管理线程池的类，它可以帮助开发者更有效地管理线程资源，提高程序的性能和并发处理能力。
在Java ThreadPool中，线程池会维护一个线程池队列，用于存放待执行的任务。当有任务到达时，线程池会从队列中取出一个空闲线程来执行任务，执行完毕后该线程会返回线程池，等待下一个任务的到来。这种方式可以避免频繁地创建和销毁线程，提高了线程的重用性和执行效率。
相比于为每个任务创建新的线程对象，使用线程池的主要优势有以下几点：
- 提高性能：线程池可以重用线程对象，避免了频繁地创建和销毁线程的开销，从而提高了程序的性能。
- 控制并发度：线程池可以限制并发执行的线程数量，避免因过多的线程导致系统资源耗尽或性能下降的问题。
- 提供任务队列：线程池可以提供一个任务队列，用于存放待执行的任务。当线程池中的线程都在执行任务时，新的任务可以暂时存放在队列中，等待有空闲线程时再执行。
- 管理线程资源：线程池可以统一管理线程的生命周期，包括线程的创建、销毁、异常处理等，简化了线程管理的复杂性。
Java ThreadPool的应用场景包括但不限于：
- Web服务器：用于处理客户端的请求，可以通过线程池来管理并发请求的处理。
- 数据库连接池：用于管理数据库连接的复用，提高数据库操作的效率。
- 并发任务处理：用于处理大量的并发任务，例如批量数据处理、文件上传下载等。
腾讯云提供了一款适用于Java开发的云计算产品，即云服务器CVM。云服务器CVM是一种弹性、可扩展的云计算服务，提供了丰富的配置选项和灵活的管理方式，适用于各种规模的应用场景。您可以通过以下链接了解更多关于腾讯云服务器CVM的信息：
https://cloud.tencent.com/product/cvm
同时，腾讯云还提供了其他与云计算相关的产品和服务，例如云数据库MySQL、云存储COS、人工智能服务等，您可以根据具体需求选择适合的产品。
相关·内容
我偶然发现了一个问题，可以总结如下：
当我手动创建线程时(例如，通过实例化java.lang.Thread)，UncaughtExceptionHandler会被适当地调用。但是，当我使用带有ThreadFactory的ExecutorService时，处理程序被省略了。我错过了什么？
public class ThreadStudy {
private static final int THREAD_POOL_SIZE = 1;
public static void main(String[] args) {
// create uncaught exception handl
浏览 0提问于2009-12-03得票数 65
回答已采纳
为了学习，我编写了以下代码，用于自定义线程池引用和编辑显示的代码( )
如代码所示，我对任务队列使用了ArrayBlockingQueue。
代码：
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
public class ThreadPoolService {
privat
浏览 0提问于2018-09-23得票数 1
回答已采纳
2回答
这是我第一次在我的新项目中使用Java，在我看到这个链接之后，我对此感到更加困惑，下面是页面上的代码，
package com.journaldev.threadpool;
public class WorkerThread implements Runnable {
private String command;
public WorkerThread(String s){
this.command=s;
}
@Override
public void run() {
System.out.println(Thr
浏览 1提问于2014-02-26得票数 1
回答已采纳
我正在编写一段代码，每当遇到文件夹时，它都会启动一个新的线程。代码如下所示，p
ublic void diff(File x,File y){
ThreadPoolExecutor executor=new ThreadPoolExecutor(10,30,2000,unit,BlockingQueue<Runnable> queue)
if(x.isDirecotry && y.isDirectory){
Runnable thread=new DThread(x,y);
Future<?> result=e
浏览 1提问于2017-04-28得票数 0
1回答
我使用ThreadPool用Java编写应用程序。首先，我创建一个新的ThreadPool：
private ExecutorService threadExecutor = Executors.newFixedThreadPool( 20 );
然后我创建了一些Runnable对象。在那之后，我会不时地执行我的ThreadPool，传递给他相同的Runnable对象：
threadExecutor.execute(serverRunnable);
我每隔20秒执行一次这个ThreadPool。我的问题是threadExecutor停止工作大约5分钟。它只是不执行Runnable对象。我注意到
浏览 0提问于2012-01-09得票数 5
回答已采纳
我试图测试番石榴并发包，如下所示。
我希望创建的线程池将执行"Runnable“类实例，然后等待终止。
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import java.util.concurrent.*;
public class MyTest {
public static void main(String [] args) {
final CountDownLatch latch = new CountDownLatch(2);
ThreadFactory
浏览 0提问于2018-12-08得票数 0
回答已采纳
1回答
任务执行器线程池
、、
尽管我有使用Java的经验，但我对并发性并不熟悉。我编写了这个线程池，它有一个任务队列。请忽略任何签名选择，如过度使用final。感谢您的反馈！
public final class ThreadPool {
// Logging
//--------------------------------------------------
private static final Logger LOGGER = LoggerFactory.getLogger(ThreadPool.class);
// Constructors
//--------------------
浏览 0提问于2022-06-29得票数 4
回答已采纳
1回答
多线程中的线程池
、、
java中的ThreadPool是什么，ThreadPool的用途是什么？
它将使用共享内存和线程安全。
cab用ThreadPool声明线程优先级。
浏览 3提问于2018-02-21得票数 1
我正在为一个贸易自动化站点构建一个Spring4RESTAPI。
在服务层中，使用SpringTaskScheduler.schedule(Runnable arg0, Date arg1)接口动态地创建一个cron作业，该接口将创建一个Runnable，在给定参数时执行，精确地执行一次。这个线程将调用另一个服务来访问我的Hibernate DAO层，并在将来做一些事情。
下面给出了配置类和实现。
@Configuration
@EnableWebMvc
@EnableScheduling
@ComponentScan("com.example")
public c
浏览 4提问于2016-10-06得票数 6
回答已采纳
使用一个池大小仅为1的ThreadPool，基本上只是为了应用程序中的不同用途而一遍又一遍地回收那个线程，这有意义吗？与其做新的Thread(Runnable())等，然后让垃圾回收器处理线程的删除，我认为只使用一个线程来处理不需要一起运行的不同作业会更有效率。
这就是我目前正在做的定义1池大小线程池的工作。
private static int poolSize = 1;
private static int maxPoolSize = 1;
private static long keepAliveTime= 10;
private static final ArrayBlocki
浏览 2提问于2010-07-21得票数 2
回答已采纳
4回答
我有50,000个任务，想用10个线程来执行它们。在Java语言中，我应该创建Executers.threadPool(10)并将runnable传递给is，然后等待处理所有。据我所知，Scala对这项任务特别有用，但我在文档中找不到解决方案。
浏览 0提问于2010-12-23得票数 43
回答已采纳
当我使用使用ThreadPool的.Net 4任务类时，如果所有线程都很忙，会发生什么？
TaskScheduler是创建一个新线程并扩展ThreadPool最大线程数，还是静静等待，直到有线程可用？
浏览 0提问于2012-03-14得票数 7
回答已采纳
3回答
从javadoc到ThreadPoolExecutor
在方法执行(java.lang.Runnable)中提交新任务时.如果运行的线程多于corePoolSize，但少于maximumPoolSize线程，则只有当队列已满时，才会创建新线程。
在这种情况下，如何使ThreadPool启动新线程而不是提交任务队列？
示例：
我有带有corePoolSize=5和maxPoolSize=10的线程和无界队列。
假设corePoolSize线程现在很忙，并且到达了新任务池必须启动新线程并执行新任务。
假设maxPoolSize线程现在很忙，并且到达了新任务池必须将任务持久化到队列中，而第一
浏览 13提问于2012-09-26得票数 2
回答已采纳
1回答
为了便于学习，我尝试在java中实现我自己的线程池。以下是我所实施的。关于这一实施，我没有几个问题：
虽然我使用的是BlockingQueue，比如内置在java中的执行器，但是我们希望我们能够提供可运行的对象(通过execute方法)。但在我的例子中，我觉得我可以创建任何对象，而不是可运行的。那么，为什么Java执行器希望运行，我试着查看源代码，但还没有弄清楚。
这个原始实现还有什么问题吗？
请找到密码。
公共类CustomThreadPool {
private final BlockingQueue<Runnable> blockingQueue;
priva
浏览 0提问于2019-09-14得票数 1
2回答
我想了解线程池的逻辑，下面有一个简单的、不正确的、没有完全实现的线程池逻辑：
class ThreadPool {
private BlockingQueue<Runnable> taskQueue;
public ThreadPool(int numberOfThreads) {
taskQueue = new LinkedBlockingQueue<Runnable>(10);
for (int i = 0; i < numberOfThreads; i++) {
new PoolTh
浏览 1提问于2012-11-04得票数 4
回答已采纳
我对ThreadPoolExecutor相对来说是个新手。我正在查看是否能够在执行之前以及在afterExecute中跟踪可运行的代码。
通过使用runnable.toString()获取afterExecute(Runnable t, Throwable t)。现在，我意识到我可以在可运行的内部放一根木头.但我很好奇这种方法会产生什么结果。
对于ThreadPoolExecutor，工作正常，runnable.toString在execute(runnable)之前和在afterExecute()中都是一样的。
然而，ScheduledThreadPoolExecutor是不同的。其后执行器
浏览 2提问于2016-08-03得票数 2
回答已采纳
我正在尝试使用Java的ThreadPoolExecutor类来运行具有固定数量的线程的大量重量级任务。每个任务都有许多地方，在这些地方它可能会因为异常而失败。
我对ThreadPoolExecutor进行了子类化，并覆盖了afterExecute方法，该方法应该提供运行任务时遇到的任何未捕获的异常。然而，我似乎不能让它工作。
例如：
public class ThreadPoolErrors extends ThreadPoolExecutor {
public ThreadPoolErrors() {
super( 1, // core threads
浏览 140提问于2010-02-12得票数 227
回答已采纳
请帮助我理解newFixedThreadPool (或缓存)的内部流程。
当我们写下面的语句时，ExecutorService e=Executors.newFixedThreadPool(3)；
e.execute(runaable1)；
e.execute(runaable2)；
e.execute(runaable3)；
e.execute(runaable4)；
e.execute(runaable5)；
在3个执行方法之前，将创建三个线程，当调用第四个execute方法时，将不会创建新线程，但工作将等待线程空闲。
我不明白这一点：“不会创建新线程，但是工作
浏览 3提问于2015-06-29得票数 3
回答已采纳
当ThreadPoolExecutor中的所有线程都完成时，我如何通知实例化ThreadPoolExecutor的主类？
ThreadPoolExecutor threadPool = null;
ThreadClass threadclass1;
ThreadClass threadclass2;
final ArrayBlockingQueue<Runnable> queue = new ArrayBlockingQueue<Runnable>(maxPoolSize);
puclic MyClass(){
threadPool = new Thr
浏览 2提问于2011-07-17得票数 3
回答已采纳
3回答
我正在处理一个多线程项目，在这个项目中，Thread可能抛出一个Error (而不是Exception)。没有找到任何关于如何在多线程中处理错误的可靠信息，我决定进行一些测试，并发现结果可能不一致。
这是我的测试代码，以及注释的结果。
public class MultiThreadError {
public static class ErrorThrowingRunnable implements Runnable{
private final boolean throwsError;
public ErrorThrowingRunnable(boo
浏览 1提问于2016-09-28得票数 3
回答已采纳
3回答
我的Java.NIO套接字服务器中有一个线程池。我有时会收到运行时错误，如Connection reset by peer或Broken Pipe等。
我的问题是:当抛出异常时，线程会被杀死吗？如果是--是否在线程池中创建了一个新线程来代替已终止的线程？？
这是我的ThreadManager：
import java.nio.channels.SocketChannel;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadsManage
浏览 4提问于2013-01-19得票数 8
1回答
是否有一个适合于大量非常短时间的任务的ExecutorService？我设想了一些内部尝试，在切换到同步等待之前忙于等待。保持任务的顺序并不重要，但是应该可以执行内存一致性(所有任务都会发生--在主线程恢复控制之前)。
下面发布的测试由100000个任务组成，每个任务在一行中生成100个double。它接受线程池的大小作为命令行参数，并且总是测试串行版本和并行版本。(如果没有给出命令行arg，则只测试串行版本。)并行版本使用一个固定大小的线程池，任务的分配甚至不是时间测量的一部分。尽管如此，并行版本从来没有比串行版本更快，我已经尝试了多达80个线程(在一台具有40个超级线程核心的机器上)。为什
浏览 3提问于2012-09-29得票数 4
回答已采纳
我发现了一个似乎还不在boost中的，但我现在也许可以使用它(除非有更好的解决方案)。
我有几百万个想要并发执行的小任务，我想使用threadpool来调度这些任务的执行。threadpool的 (大致)提供了这个示例：
#include "threadpool.hpp"
using namespace boost::threadpool;
// A short task
void task()
{
// do some work
}
void execute_with_threadpool(int poolSize, int numTasks)
{
//
浏览 0提问于2011-10-26得票数 3
回答已采纳
这是我的第一个问题。我试图定期使用ScheduledThreadPoolExecutor从java运行并行python脚本(即同一个脚本的多个实例)。我试图做的是使用ProcessBuilder类。为了测试这个概念，我将第一个脚本放入无限循环中，而第二个脚本编写了一些文件并退出。我需要创建的Python脚本应该是相同的，因此我尝试从实现runnable的同一个类的多个实例中运行这两个脚本。
然而，第二个脚本从未启动。我通过创建许多具有完全相同可运行性的类来解决这个问题。但是，有10-20个相同的课程似乎是非常不切实际的。所以我能在一个可运行的范围内做到这一点吗？下面的代码展示了我如何尝试使用P
浏览 2提问于2014-02-27得票数 2
回答已采纳
我处理了一个线程应用程序的设计，该应用程序具有以下要求:它必须有一个基于时间的动态线程数(峰值/非峰值)。
我做了家庭作业，并研究了最好的方法，我发现java有一个名为ThreadPoolExecutor：java.util.concurrent.ThreadPoolExecutor.ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)的类。
这里关注的两个变量是corePoolSi
浏览 3提问于2015-02-17得票数 3
回答已采纳
3回答
下面的方法是否可能导致线程挂起，从而导致其他线程挂起，从而最终建立堆栈并使应用服务器崩溃？
private static Hashtable content = new Hashtable();
private static int cleanout;
private static void cleanoutCache() {
if(cleanout > 50000) {
synchronized(PollCacheManager.class) {
Enumeration emu = content.keys();
浏览 7提问于2012-02-08得票数 1
回答已采纳
2回答
我已经为.net Core3.0Web应用程序做了一个干净的项目，我正在努力理解ThreadPool是如何在C#中工作的。
namespace TestASPSelf.Controllers
{
public class HomeController : Controller
{
private readonly ILogger<HomeController> _logger;
public static int countThread = 0;
public HomeController(ILogger<H
浏览 3提问于2019-10-22得票数 0
我正在使用Java ExecutorService (ThreadPool)来执行任务&更新UI，而特定的活动在前台(可见)。
问题:我想要的是当用户切换到另一个活动时，我希望停止/取消所有任务(无论是排队还是正在运行)。为此，我必须在通过调用ExecutorService ()检查未来对象状态后，对ExecutorService提交方法返回的未来对象使用isDone关机/快门现在方法或取消(True)。这将将中断的相应线程标志设置为TRUE，必须检查可调用实现中的(Thread.currentThread.isInterrupted())，以确定是否中断，退出任务/线程。问题是我是调
浏览 1提问于2017-07-29得票数 0
回答已采纳
3回答
执行器对象是否意味着在shutdown之后被重用？我的意思是，如果在执行器终止后调用shutdown或shutdownNow，我应该做new来创建一个新的线程池，还是可以以某种方式“重置”以前终止的执行程序的/reuse并重用它？
更新：
如果我需要创建新的线程池，我如何“理解”上一个线程池已经停止？
例如：
public void startPool(){
if(threadPool != null && !threadPool.isShutdown()){
return;
}
threadPool = Executors.newCached
浏览 7提问于2013-02-20得票数 22
回答已采纳
1回答
我正在编写一个Java程序来解决这个问题：
我有一个包含值的平衡树(即Java语言中的TreeSet )。我有一个"Task“对象，它们可以做两件事中的任何一件:尝试在树中查找一个值，或者向树中添加一个值。我将拥有这些“任务”对象的列表(我在Java语言中使用了LinkedList )，并创建线程来逐个读取和删除该列表中的任务，并执行它们所需的操作(即在树中查找或添加一个值)。我已经为我的任务列表创建了一个同步的"remove“方法(它只是调用底层LinkedList的"remove”方法)。我还定义了要同步的树的"add“方法...(我不知道是否有必要同步它，
浏览 0提问于2014-07-17得票数 1
1回答
我同时做了一些网络请求，并在安卓系统中使用HTTPClient获得响应。我使用threadsafeclientconnmanager来实现线程安全连接。
为了同时做到这一点，我使用了Java ThreadPool。
private enum STATE { state1, state2, state3 };
ExecutorService executor = Executors.newFixedThreadPool(nThreads);
并提交3个可运行的：
executor.submit(new Processor(state1));
executor.submit(new Proces
浏览 0提问于2013-12-27得票数 0
public class TaskA implements Runnable {
....
}
public class TaskB implements Runnable {
....
}
我有两个可运行的类TaskA，TaskB。我希望有一个TaskManager来运行这两个任务，并且有可能在将来添加更多的任务。因此，我有如下的TaskManager：
public class TaskManager {
private ThreadPoolExecutor threadPool;
private Object task;
public TaskManager(T
浏览 0提问于2017-03-07得票数 3
回答已采纳
我看了一下JAVA，并尝试使用ExecutorService。不幸的是，我的executor没有启动我的runnable对象。我试图从不同的XML文件中获取一些信息，这些文件存储在文件列表中。
FileFinder fileFinder = new FileFinder(path);
List<File>files = fileFinder.getFiles();
ExecutorService threadPool = Executors.newFixedThreadPool(configReader.getThreadcount(), new Thr
浏览 7提问于2016-09-03得票数 0
我读了一些关于生产者和消费者在Java中的实现。大多数在线代码示例显示了具有以下基本对象的解决方案：
用作数据管道的阻塞队列
N推送消息到队列的生产者个数
N从队列中轮询数据的消费者数量
通常，使用者被提交到线程池，线程池完成实现。
我研究过的另一个选择是，简单地将任务作为一个runnable对象提交给FixedThreadPool。
在此实现中，用于处理消息的业务逻辑在Runnable对象的run()方法中实现。当我们有想要处理的新消息时，我们可以简单地将该类型的新任务提交给FixedThreadPool，然后...就这样。运行线程的数量由FixedThreadPool实现以及消息轮询逻辑来
浏览 1提问于2019-06-19得票数 0
2回答
全球执行者服务
、、、、
我想使用一个公共线程池，它可以在我的应用程序的任何地方使用。我是否应该在主类中创建一个静态执行器服务。那就在需要的地方使用它？目前，我在我的主要类(MyMainApplication.java)中有这个
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
public static final ThreadPoolExecutor getExecutor(int corePoolSize, int maxPoolSize, int keepAlive) {
浏览 0提问于2018-10-31得票数 3
回答已采纳
1回答
在花了大量时间处理线程池概念之后，通过阅读关于博客数量的不同代码和在Stackoverflow.com上发布问题，现在我得到了这个概念的清晰图像。但与此同时，我在代码中发现了一些疑问。
当done.workerBegin(); pool.assign(新的TestWorkerThread());在TestThreadPool类中执行时，它调用完成的类中的方法，在该方法中增加_activeThreads变量。但我认为，_activeThreads逻辑上的是不正确的，因为如果线程数(在本例中为2)少于任务数(在TestThreadPool类中给出)(在本例中为5)，则会增加(即_activeT
浏览 0提问于2013-01-23得票数 1
回答已采纳
1回答
我有一个IntentService，它应该像管理器一样工作，并在提交给ThreadPool的队列(Runnable)中创建任务。
我对IntentService的生命周期有点困惑：
protected abstract void onHandleIntent (Intent intent)方法已经在分离的线程上运行。在onHandleIntent中，我将创建一个新的可运行实例，并将其提交给ThreadPool。我的服务是这样的：
public class SyncService extends IntentService {
private final ThreadPoolE
浏览 1提问于2013-12-05得票数 6
回答已采纳
2回答
我有一个具有100K+标识符的数据库表。任务是读取这些ID中的每一个并启动耗时的浓缩过程，其结果一旦完成，就需要持久化到数据库中。
当前基于Java的解决方案基于以下流程：
将数据库中的所有标识符加载到内存中；
用10个线程创建ThreadPool；
开始执行丰富的并行处理/任务，并将数据持久化到数据库(每个任务50个in，并行)。所有任务都被添加到队列中。
Java ThreadPool和Executor框架用于适应这一功能。
未来的预期是，标识符的数量将急剧增加，因此为了避免潜在的内存压力--我正在考虑在现有任务之一完成后(即按需)开始批量读取is并创建相关任务。
例如
浏览 4提问于2020-12-15得票数 1
3回答
通常，线程可以通过两种方式创建。
扩展线程类
实现可运行的接口
通过阅读所有教程，所有人都说实现可运行接口总是很好的，因为如果通过扩展(第一种方法)创建，您就不能扩展任何其他类。而且，如果我们通过扩展创建线程，那么每个线程都会创建新的对象，而如果通过实现创建线程，那么所有线程都将共享同一个对象。
我的问题是，如果实现Runnable是最好的选择，而扩展线程是错误的做法，为什么java有此选项？我相信如果我们通过扩展创建线程一定有一定的优势(我认为我们应该使用扩展线程方法，因为没有其他父类不是唯一的答案)。
提前感谢
浏览 1提问于2018-08-20得票数 0
回答已采纳
2回答
似乎有许多不同的方法可以创建线程(Runnable vs Thread类)和ThreadPools。
在Java中创建和池化线程的效率和最有效(性能方面)的技术有什么区别吗？
浏览 0提问于2012-04-07得票数 2
回答已采纳
4回答
所以我循环了大约20000次。每次循环时，我都会创建一个新线程。线程基本上只调用一个方法。这个方法相当慢，需要4秒钟才能完成。它会去抓取一些页面(我们有权限去抓取)。我在循环中添加了一个1秒的延迟，这将确保一次只有4个页面被丢弃。我的问题是，一旦方法完成，该线程会发生什么？
Thread.Sleep(1000);
Thread t = new Thread(() => scraping(asin.Trim(), sku.Trim()));
t.Start();
浏览 0提问于2011-06-17得票数 1
回答已采纳
2回答
有10个线程，我有15个任务。现在，我已经将所有这些任务提交给这些线程。我需要将所有这些线程输出到一个我没有成功的文件中。
我是通过运行所有线程来获得输出的。
ThreadPool.java (创建线程池并将所有任务添加到阻塞队列并提交)
public class ThreadPool {
ExecutorService execService = null;
BlockingQueue<Callable<String[]>> tasks = null;
BlockingQueue<String> queue = null;
浏览 0提问于2013-06-09得票数 3
3回答
重复网络任务的最佳实践？
、、、
我有一个小型的Android应用程序，在这个应用程序中，我需要每隔几秒钟就做一些FTP内容。在了解到在UI线程上运行网络内容并不是Android真正喜欢的事情之后，我开始讨论这个解决方案：
// This class gets declared inside my Activity
private class CheckFtpTask extends AsyncTask<Void, Void, Void> {
protected Void doInBackground(Void... dummy) {
Thread.currentThread().setNa
浏览 4提问于2013-09-13得票数 5
回答已采纳
我在一个独立的env上使用Spring3.1。
(这个问题与Spring无关。在一个独立的环境中也是如此。)
我实现了一个侦听器，它接收来自主题的消息。信息率非常高(约20/30米/秒)。
有些消息可能需要更多的处理时间。
侦听器与相同的实例一起工作，这意味着如果一条消息处理得太久，它会对我们的性能产生很大影响。
我们考虑使用自己的对象池，而不是使用相同的侦听器实例，但随后我发现了Executors(java.util.concurrent.Executors).。
因此，对于每个接收到的消息，将为其分配一个不同的线程。这将确保我们的侦听器实例可以自由地并行处理消息。
private Exec
浏览 1提问于2012-12-17得票数 7
回答已采纳
我有三种类型的任务：A, B, C。
我想在N个线程中并行运行这些任务。让我们假设，任务列表如下：
A, B, C, B, C, A, B, C
当然，我可以使用ExecutorService实现多线程执行，但问题是，一次最多只需要执行类型为的一个任务。必须顺序执行C类型的其他任务，但必须与任务A和/或B并行执行。
例如，3线程执行器可能处于以下任一状态：
A B C
A A A
A C B
B B C
B B B
B C
A C
A B
C
...
(允许一次执行A或B类型的多个任务，但最多只能一次执行C类型的任务)
有什么方法可以在Java中实现这一点吗？
更新
这是我要做的，这
浏览 1提问于2015-04-17得票数 2
回答已采纳
我目前正试图通过将一些工作从UI线程移动到其他线程来使我的GridView滚动更平滑，但我得到了奇怪的行为:有时一个图像被绘制到多个视图。我正在使用Xamarin (C#)。
下面你可以找到我当前代码的简化版本。在我的网格视图适配器中，从GetView()中调用LoadShowImageAsync。如果我以单线程方式调用LoadShowImageDoWork()，一切都很好，但是当我通过ThreadPool调用它时，它会显示出奇怪的行为。在调试日志中，我看到该方法是在对图像进行解码后留下的，随后对几个图像组合执行RunOnUiThread内容。然后对其他一些图像进行解码，然后为它们组合RunO
浏览 1提问于2013-03-19得票数 0
我正在编写一个具有集成服务器的客户机，该服务器应该无限期地等待新的连接，并在线程上处理每个连接。
我希望在主线程上的系统范围内处理可用消息处理程序中接收的字节数组。但是，目前的处理显然是在客户端线程上完成的。
我已经看过了ExecutorService的期货提交()，但是当我在服务器中创建客户机连接时，数据将返回给服务器线程。如何将它从那里返回到主线程(可能在同步数据包存储中)？在不阻塞服务器的情况下处理它？
我目前的实现如下：
public class Server extends Thread {
private int port;
private Executor
浏览 4提问于2010-12-22得票数 1
回答已采纳
我知道不应该调用run方法来启动一个新的线程执行，但我指的是，它们在另一个run方法中调用了runnable.run();，这似乎意味着它启动了一个新线程，或者它根本没有启动一个新线程，它只是创建一个新线程并在同一个线程中运行所有可运行的线程，也就是说，一个任务一个任务？
这是文章提到的代码。
public class ThreadPool {
private BlockingQueue taskQueue = null;
private List<PoolThread> threads = new ArrayList<PoolThread>();
浏览 3提问于2018-05-29得票数 6
回答已采纳
6回答
我有一个方法void DoWork(object input)，大约需要5秒才能完成。我读到过Thread比ThreadPool更适合这些更长的操作，但我遇到了一个问题。
我单击了一个调用threadRun.Start(input)的按钮，该按钮运行并正常完成。我再次单击该按钮，收到以下异常：
Thread is running or terminated; it cannot restart.
你不能“重用”一个线程吗？我应该使用ThreadPool吗？为什么与ThreadPool相比，线程“更适合更长的操作”？如果你不能重用一个线程，为什么还要使用它(即它有什么好处)？
浏览 0提问于2012-03-08得票数 12
回答已采纳
我有下面的代码，我有3个类
ThreadPoolTest.java
Parent.java(可运行)
Child.java(可运行)
我在每10秒从ThreadPoolTest.java中调度一次父线程之后，一旦启动父线程，它就会在它的run()中创建100个子线程。
我的要求是每次都启动父线程，我想使用相同的线程执行程序.
目前我已经给出了50的游泳池大小。在运行时，我想更新每个父线程执行的池大小。
这能实现吗？(有建议吗？)
如果是，我们如何才能做到这一点？
public class ThreadPoolTest {
public static void mai
浏览 1提问于2018-01-15得票数 0
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
