java.util.concurrent简称JUC，日常总结
CountDownLatch
CountDownLatch的用法是讲一个程序分为N个互相独立的可解决任务，并创建值为N的CountDownLatch。当每一个任务完成是，都会在这个锁存器上调用countDown，等待问题被解决的任务调用这个锁存器的await，将他们自己拦住，直至锁存器技术结束。
构造方法
/**
* 构造一个指定次数的CountDownLatch
*
* @param count 可以countDown的次数
*/
public CountDownLatch(int count) {
if (count < 0) throw new IllegalArgumentException("count < 0");
this.sync = new Sync(count);
}
常用方法
/**
* 调用await()方法的线程会被挂起。他会等待直到count值的为0才继续执行或者线程中断。
* 如果当前计数为0，则此方法立即返回。
* 如果当前计数大于0，则当前线程出于线程调度目的被禁用，并处于休眠状态，直到发生以下2种情况之一：
* 1.调用countDown方法后计数为0。
* 2.其他线程中断当前线程
*/
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
/**
* 调用await()方法的线程会被挂起。他会等待直到count值的为0才继续执行或者线程中断或经过指定的等待时间。
* 如果当前计数为0，则此方法立即返回。
* 如果当前计数大于0，则当前线程出于线程调度目的被禁用，并处于休眠状态，直到发生以下3种情况之一：
* 1.调用countDown方法后计数为0。
* 2.其他线程中断当前线程
* 3.经过指定的等待时间
*/
public boolean await(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}
/**
* 减少锁存器的计数，如果计数为0，则释放所有等待的线程。如果当前计数大于0。则会递减。如果启用了新线程调度，则所有线程都在等待。如果当前计数等于0，则什么也不会发生。
*/
public void countDown() {
sync.releaseShared(1);
}
举一个简单的例子
使用CountDownLatch实现类似计数器的功能。比如有一个任务A，它要等待其他4个任务执行完毕之后才能继续执行。
package com.test.juc;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.CountDownLatch;
/**
* @author liao
* @version 1.0.0
* @date 2022/3/14 15:24
**/
@Slf4j
public class TestCountDownLatchDemo {
public static void main(String[] args) {
final CountDownLatch latch = new CountDownLatch(2);
new Thread(() -> {
try {
log.info("正在执行");
Thread.sleep(3000);
log.info("执行完毕");
latch.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
new Thread(() -> {
try {
log.info("正在执行");
Thread.sleep(3000);
log.info("执行完毕");
latch.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
try {
log.info("等待2个子线程执行完毕...");
latch.await();
log.info("2个子线程已经执行完毕");
log.info("继续执行主线程");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
执行结果
15:29:24.214 [Thread-1] INFO com.test.juc.TestCountDownLatchDemo - 正在执行
15:29:24.214 [Thread-0] INFO com.test.juc.TestCountDownLatchDemo - 正在执行
15:29:24.214 [main] INFO com.test.juc.TestCountDownLatchDemo - 等待2个子线程执行完毕...
15:29:27.225 [Thread-1] INFO com.test.juc.TestCountDownLatchDemo - 执行完毕
15:29:27.225 [Thread-0] INFO com.test.juc.TestCountDownLatchDemo - 执行完毕
15:29:27.226 [main] INFO com.test.juc.TestCountDownLatchDemo - 2个子线程已经执行完毕
15:29:27.226 [main] INFO com.test.juc.TestCountDownLatchDemo - 继续执行主线程
实战
当后台需要处理一批数据业务操作，我们可以充分利用CPU进行同时处理每个最小单元的业务，等待每个最小单元的数据业务全部处理完成，在继续执行主业务流程。例如：我们需要处理一批数据10条。我们把这批数据10条分为3个批次，每个子线程处理一个批次的数据业务。子线程全部处理完成。主线程才继续执行。
package com.test.juc;
import com.bean.HuluActivityRegistrationBatchRecordDo;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.ListUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* @Description:
* @Author: 李澳 hljliao@foxmail.com
* @Date: 2021 2021/12/31 15:16
*/
@Slf4j
public class TestCountDownLatch {
private static final int CORE_POOL_SIZE = Runtime.getRuntime().availableProcessors();
private static final int MAX_POOL_SIZE = Runtime.getRuntime().availableProcessors() * 2;
private static final int QUEUE_CAPACITY = 100;
private static final int KEEP_ALIVE_TIME = 30;
public static void main(String[] args) {
ThreadPoolExecutor executorService = new ThreadPoolExecutor(
CORE_POOL_SIZE,
MAX_POOL_SIZE,
KEEP_ALIVE_TIME,
TimeUnit.SECONDS,
new LinkedBlockingDeque<>(500),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.CallerRunsPolicy()
);
List<HuluActivityRegistrationBatchRecordDo> recordList = new ArrayList<>();
for (int i = 1; i <= 10; i++) {
// 手动组装10条模拟数据
HuluActivityRegistrationBatchRecordDo bean = new HuluActivityRegistrationBatchRecordDo();
bean.setId(String.valueOf(i));
recordList.add(bean);
}
// 以长度4拆分10条list为3组
List<List<HuluActivityRegistrationBatchRecordDo>> recordLists = ListUtils.partition(recordList, 4);
java.util.concurrent.CountDownLatch downLatch = new java.util.concurrent.CountDownLatch(recordLists.size());
// 处理3组数据
recordLists.forEach(list -> {
Runnable runnable = () -> {
try {
// 处理每组数据
list.forEach(record -> {
try {
log.info("处理" + record.getId());
Thread.sleep(10000);
} catch (Exception e) {
}
});
} finally {
downLatch.countDown();
log.info("线程名称[{" + Thread.currentThread().getName() + "}] ,线程计数器:[{" + downLatch.getCount() + "}]");
}
};
executorService.execute(runnable);
});
executorService.shutdown();
try {
downLatch.await();
log.info("全部处理完成");
} catch (InterruptedException e) {
} finally {
}
log.info("继续执行主线程");
}
}
执行结果
17:15:28.863 [pool-1-thread-3] INFO com.test.juc.TestCountDownLatch - 处理9
17:15:28.863 [pool-1-thread-1] INFO com.test.juc.TestCountDownLatch - 处理1
17:15:28.863 [pool-1-thread-2] INFO com.test.juc.TestCountDownLatch - 处理5
17:15:38.879 [pool-1-thread-3] INFO com.test.juc.TestCountDownLatch - 处理10
17:15:38.879 [pool-1-thread-2] INFO com.test.juc.TestCountDownLatch - 处理6
17:15:38.879 [pool-1-thread-1] INFO com.test.juc.TestCountDownLatch - 处理2
17:15:48.883 [pool-1-thread-2] INFO com.test.juc.TestCountDownLatch - 处理7
17:15:48.883 [pool-1-thread-1] INFO com.test.juc.TestCountDownLatch - 处理3
17:15:48.883 [pool-1-thread-3] INFO com.test.juc.TestCountDownLatch - 线程名称[{pool-1-thread-3}] ,线程计数器:[{2}]
17:15:58.894 [pool-1-thread-2] INFO com.test.juc.TestCountDownLatch - 处理8
17:15:58.894 [pool-1-thread-1] INFO com.test.juc.TestCountDownLatch - 处理4
17:16:08.900 [pool-1-thread-2] INFO com.test.juc.TestCountDownLatch - 线程名称[{pool-1-thread-2}] ,线程计数器:[{1}]
17:16:08.900 [pool-1-thread-1] INFO com.test.juc.TestCountDownLatch - 线程名称[{pool-1-thread-1}] ,线程计数器:[{0}]
17:16:08.900 [main] INFO com.test.juc.TestCountDownLatch - 全部处理完成
17:16:08.900 [main] INFO com.test.juc.TestCountDownLatch - 继续执行主线程
总结
CountDownLatch底层也是由AQS，用来同步一个或多个任务的常用并发工具类，强制它们等待由其他任务执行的一组操作完成
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
