countDownLatch-多个任务并行执行，等待相同的时间后，获取最终的结果

最新推荐文章于 2023-08-09 17:59:27 发布

原创最新推荐文章于 2023-08-09 17:59:27 发布

· 438 阅读

0 ·

版权

文章标签：

#java #servlet #jvm

java 专栏收录该内容

45 篇文章

订阅专栏

线程池工具类：

package com.common.core.pool;

import io.netty.util.concurrent.DefaultThreadFactory;

import java.util.concurrent.*;

/**
 * @author
 */
public class CommonThreadPoolExecutor {
    
    /**
     * The core pool size.
     */
    private static final int CORE_POOL_SIZE = 8;
    /**
     * The max pool size.
     */
    private static final int MAXI_MUM_POOL_SIZE = 32;
    /**
     * The keepalive time.
     */
    private static final long KEEPALIVE_TIME = 120L;
    /**
     * block queue
     */
    private static final BlockingQueue<Runnable> BLOCKING_QUEUE_1 = new LinkedBlockingQueue<>(10000);
    private static final BlockingQueue<Runnable> BLOCKING_QUEUE_2 = new LinkedBlockingQueue<>(10000);
    
    /**
     * The thread name
     */
    private static final String THREAD_NAME_1 = "common-level-1";
    private static final String THREAD_NAME_2 = "common-level-2";
  
    
    /**
     * 线程池一
     */
    public static final ExecutorService EXECUTOR_LEVEL_1 = new java.util.concurrent.ThreadPoolExecutor(
            CORE_POOL_SIZE,
            MAXI_MUM_POOL_SIZE,
            KEEPALIVE_TIME,
            TimeUnit.SECONDS,
            BLOCKING_QUEUE_1,
            new DefaultThreadFactory(THREAD_NAME_1),
            new ThreadPoolExecutor.CallerRunsPolicy());
    
    /**
     * 线程池二
     */
    public static final ExecutorService EXECUTOR_LEVEL_2 = new java.util.concurrent.ThreadPoolExecutor(
            CORE_POOL_SIZE,
            MAXI_MUM_POOL_SIZE,
            KEEPALIVE_TIME,
            TimeUnit.SECONDS,
            BLOCKING_QUEUE_2,
            new DefaultThreadFactory(THREAD_NAME_2),
            new ThreadPoolExecutor.CallerRunsPolicy());
    
    
}

countDownLatch的使用：

List<Student> students = new ArrayList<>();
List<Teacher> teachers = new ArrayList<>();
CountDownLatch countDownLatch = new CountDownLatch(4);

CommonThreadPoolExecutor.EXECUTOR_LEVEL_2.execute(() -> {
            List<Student> studentList = getStudentList();
            students.addAll(studentList);
            countDownLatch.countDown();
});
       
CommonThreadPoolExecutor.EXECUTOR_LEVEL_2.execute(() -> {
            List<Teacher> teacherList = getTeacherList();
            teachers.addAll(teacherList);
            countDownLatch.countDown();
});
try {
     countDownLatch.await(10, TimeUnit.SECONDS);
} catch (InterruptedException e) {
     e.printStackTrace();
}