两种等待多线程执行结束的方式

原创已于 2024-11-01 09:45:42 修改 · 816 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

于 2023-09-13 17:56:37 首次发布

博客介绍了Java中的CountDownLatch和ThreadPoolExecutor线程池。CountDownLatch是同步工具类，用计数器协调多线程同步，计数器为0时等待线程恢复执行。还提到通过线程池实现相关功能，包括构建线程池类、创建线程池对象并调用方法，且都给出示例代码。

1，CountDownLatch

CountDownLatch是一个同步工具类，用来协调多个线程之间的同步，用来作为线程间的通信而不是互斥作用。
CountDownLatch能够使一个线程在等待另外一些线程完成各自工作之后，再继续执行。
使用一个计数器进行实现，计数器初始值就是线程的数量。
当每个被计数的线程完成任务后，计数器值减一，当计数器的值为0时，表示所有线程都已经完成了任务，然后在CountDownLatch上等待的线程就可以恢复执行。
示例代码如下：

  // CountDownLatch指定的数量应与下面循环的数量一致
  CountDownLatch countDownLatch = new CountDownLatch(20);
  // 创建线程池
  ExecutorService fixedNumThreadPool = Executors.newFixedThreadPool(10);

  for (int i=0;i<20;i++) {
      fixedNumThreadPool.execute(new Runnable() {
          @Override
          public void run() {
             /* 多线程处理逻辑  */         
             
             countDownLatch.countDown();
          }
     });
 }

 // 等待多线程执行完毕
 countDownLatch.await();

2，ThreadPoolExecutor 线程池

通过线程池实现，示例代码如下：

2.1，构建线程池类

package com;

import com.google.common.collect.Maps;
import java.util.Map;
import java.util.concurrent.*;

public class FixedThreadPool {
    private static int MAX_SIZE_POOL = 100;
    private static int CORE_SIZE_POOL = 50;
    private static long TIME_OUT = 30L;
    private ThreadPoolExecutor threadPool = new ThreadPoolExecutor(CORE_SIZE_POOL,MAX_SIZE_POOL,TIME_OUT,TimeUnit.SECONDS, new LinkedBlockingQueue<>());

    public Future<Map<String,Object>> submitTask() {
        return threadPool.submit(new Callable<Map<String,Object>>() {
            @Override
            public Map<String,Object> call() {
                Map<String,Object> resultMap = Maps.newConcurrentMap();
                
                // 多线程处理逻辑，可以返回数据

                return resultMap;
            }
        });
    }
}

2.2，创建线程池对象，调用方法

        FixedThreadPool threadPool = new FixedThreadPool();
        Map<Integer, Future<Map<String, Object>>> futureMap = new HashMap<>();
        for (int i=0;i<20;i++) {
            // 多线程处理
            Future<Map<String, Object>> resultFuture = fixedThreadPool.submitTask();
            futureMap.put(i,resultFuture);
        }

        // 等待线程执行完成,处理返回结果
        for (Map.Entry<Integer, Future<Map<String, Object>>> entry : futureMap.entrySet()) {
            Map<String, Object> resultMap = entry.getValue().get();

            // resultMap 为返回的数据，可以进行后续业务处理
        }