如何在Java中使用固定数量的线程来运行一定数量的任务

我有特定数量的线程

THREAD\u POOL\u SIZE

和一系列可以超过线程数量的任务。我想使用这些

k

线程来运行我的所有任务。我将这些任务放在

阻塞队列中

，每个线程返回一个结果，该结果应在以后聚合

在这里，我编写了一个简单的程序，其中的任务是从1到100的数字，我试图计算所有数字的总和。每个线程将从阻塞队列中选择一个数字并返回它。我正在使用

Future

收集我的结果，并在以后求和

使用BlockingQueue的原因是，我试图解决一个更大的问题，在这个问题中，我可以在阻塞队列中有任务，并且我有一定数量的线程来运行这些任务

我想知道如何修复下面的代码，使

k

线程继续处理阻塞队列中的条目

static class Consumer implements Callable<Integer> {
    private BlockingQueue<Integer> sharedQueue;

    public Consumer(BlockingQueue<Integer> sharedQueue) {
        this.sharedQueue = sharedQueue;
    }

    @Override
    public Integer call() {
        while(true){
            try {
                return sharedQueue.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public static void main(String[] args) throws Exception {
    int THREAD_POOL_SIZE = 10;
    int BLOCKING_QUEUE_SIZE = 100;
    BlockingQueue<Integer> sharedQueue = new ArrayBlockingQueue<>(BLOCKING_QUEUE_SIZE);
    ExecutorService execService = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
    List<Future<Integer>> futures = new ArrayList<>();
    for (int i = 0; i < BLOCKING_QUEUE_SIZE; i++) {
        sharedQueue.add(i);
    }

    for (int i = 0; i < THREAD_POOL_SIZE; i++) {
        futures.add(execService.submit(new Consumer(sharedQueue)));
    }

    int total = 0;
    for (Future<Integer> future : futures) {
        try {
            total += future.get();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    System.out.println("Total count: " + total);
    execService.shutdown();
}

静态类使用者实现可调用{
私有阻塞队列共享队列；
公共消费者（阻止队列共享队列）{
this.sharedQueue=sharedQueue；
}
@凌驾
公共整数调用（）{
while（true）{
试一试{
返回sharedQueue.take（）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
}
}
公共静态void main（字符串[]args）引发异常{
int线程池大小=10；
int阻塞队列大小=100；
BlockingQueue sharedQueue=新阵列BlockingQueue（阻塞队列大小）；
ExecutorService Executors=Executors.newFixedThreadPool（线程池大小）；
列表期货=新的ArrayList（）；
对于（int i=0；i

---

谢谢你的帮助

您需要向执行人添加100个期货，而不是10个：

for (int i = 0; i < THREAD_POOL_SIZE; i++) {

for（inti=0；i

应该是：

for (int i = 0; i < 100; i++) {

for（int i=0；i<100；i++）{

---

很奇怪，你认为这个队列到底在添加什么。没有它，你可以大大简化你的代码

int THREAD_POOL_SIZE = 10;
ExecutorService execService = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
List<Future<Integer>> futures = new ArrayList<>();

for (int i = 0; i < 100; i++) {
    final int j = i;
    futures.add(execService.submit(() -> j));
}

int total = 0;
for (Future<Integer> future : futures) {
    try {
        total += future.get();
    } catch (Exception e) {
        e.printStackTrace();
    }
}
System.out.println("Total count: " + total);
execService.shutdown();

int线程池大小=10；
ExecutorService Executors=Executors.newFixedThreadPool（线程池大小）；
列表期货=新的ArrayList（）；
对于（int i=0；i<100；i++）{
最终int j=i；
futures.add（execService.submit（（）->j））；
}
int-total=0；
for（未来：未来）{
试一试{
total+=future.get（）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
System.out.println（“总计数：+Total”）；
execService.shutdown（）；

您需要向执行人添加100个期货，而不是10个：

for (int i = 0; i < THREAD_POOL_SIZE; i++) {

for（inti=0；i

应该是：

for (int i = 0; i < 100; i++) {

for（int i=0；i<100；i++）{

---

很奇怪，你认为这个队列到底在添加什么。没有它，你可以大大简化你的代码

int THREAD_POOL_SIZE = 10;
ExecutorService execService = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
List<Future<Integer>> futures = new ArrayList<>();

for (int i = 0; i < 100; i++) {
    final int j = i;
    futures.add(execService.submit(() -> j));
}

int total = 0;
for (Future<Integer> future : futures) {
    try {
        total += future.get();
    } catch (Exception e) {
        e.printStackTrace();
    }
}
System.out.println("Total count: " + total);
execService.shutdown();

int线程池大小=10；
ExecutorService Executors=Executors.newFixedThreadPool（线程池大小）；
列表期货=新的ArrayList（）；
对于（int i=0；i<100；i++）{
最终int j=i；
futures.add（execService.submit（（）->j））；
}
int-total=0；
for（未来：未来）{
试一试{
total+=future.get（）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
System.out.println（“总计数：+Total”）；
execService.shutdown（）；

只要看一眼你的代码就可以看出你的代码有点过分。有一些java类为你处理这些东西。请看一下类和类。ExecutorService及其特定实现提供了一个托管线程池。你所需要做的就是调用类

Executor的方法
newFixedThreadPool
s

，然后将所有任务提交到该池。你不需要任何队列，你的任务将由线程池管理。你可以收集你的

未来

，并监视任务完成的时间。这比你认为的要简单得多

即使看一眼你的代码也会发现你的代码是一种过度使用的方式。有java clas为您处理这些内容的SE。请查看类和类。ExecutorService及其特定实现提供了一个托管线程池。您需要做的就是调用类的方法

Executors

，然后将所有任务提交到该池。您不需要任何队列，您的任务将是人工的被线程池老化。你可以收集你的

未来

并监视任务何时完成。这比你认为的要简单得多

感谢你捕捉到了错误。使用BlockingQueue的原因是因为我试图解决一个更大的问题，我可以将任务放在阻塞队列中，并且我有一定数量的线程运行这些任务。感谢您捕获错误。使用BlockingQueue的原因是因为我试图解决一个更大的问题，即我可以在阻塞队列中有任务，并且我有一定数量的线程来运行这些任务。