CountDownLatch（也叫閉鎖）是一個同步協助類，允許一個或多個執行緒等待，直到其他執行緒完成操作集。
CountDownLatch 使用給定的計數值（count）初始化。 await 方法會阻塞直到目前的計數值（count）由於 countDown 方法的呼叫達到 0，count 為 0 之後所有等待的執行緒都會被釋放，並且隨後對await方法的呼叫都會立即傳回。
建構方法：
//参数count为计数值
public CountDownLatch(int count) {};// 调用 await() 方法的线程会被挂起，它会等待直到 count 值为 0 才继续执行
public void await() throws InterruptedException {};
// 和 await() 类似，若等待 timeout 时长后，count 值还是没有变为 0，不再等待，继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException {};
// 会将 count 减 1，直至为 0
public void countDown() {};首先建立實例CountDownLatch countDown = new CountDownLatch(2);
需要同步的執行緒執行完後，計數-1，countDown.countDown();
#需要等待其他執行緒執行完畢之後，再執行的線程，呼叫countDown.await()實作阻塞同步。
如下。
CountDownLatch 一般用作多執行緒倒數計數器，強制它們等待其他一組（CountDownLatch的初始化決定）任務執行完成。
CountDownLatch的兩個使用情境：
#讓多個執行緒等待，模擬並發。
讓單一執行緒等待，多個執行緒（任務）完成後，進行總計合併。
import java.util.concurrent.CountDownLatch;
/**
* 让多个线程等待：模拟并发，让并发线程一起执行
*/
public class CountDownLatchTest {
public static void main(String[] args) throws InterruptedException {
CountDownLatch countDownLatch = new CountDownLatch(1);
for (int i = 0; i < 5; i++) {
new Thread(() -> {
try {
// 等待
countDownLatch.await();
String parter = "【" + Thread.currentThread().getName() + "】";
System.out.println(parter + "开始执行……");
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
Thread.sleep(2000);
countDownLatch.countDown();
}
}很多時候，我們的並發任務，存在前後依賴關係；例如數據詳情頁需要同時調用多個接口獲取數據，並發請求獲取到數據後、需要進行結果合併；或者多個數據操作完成後，需要數據check；這其實都是：在多個執行緒(任務)完成後，進行總計合併的場景。
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;
/**
* 让单个线程等待：多个线程(任务)完成后，进行汇总合并
*/
public class CountDownLatchTest3 {
//用于聚合所有的统计指标
private static Map map = new ConcurrentHashMap();
//创建计数器，这里需要统计4个指标
private static CountDownLatch countDownLatch = new CountDownLatch(4);
public static void main(String[] args) throws Exception {
//记录开始时间
long startTime = System.currentTimeMillis();
Thread countUserThread = new Thread(() -> {
try {
System.out.println("正在统计新增用户数量");
Thread.sleep(3000);//任务执行需要3秒
map.put("userNumber", 100);//保存结果值
System.out.println("统计新增用户数量完毕");
countDownLatch.countDown();//标记已经完成一个任务
} catch (InterruptedException e) {
e.printStackTrace();
}
});
Thread countOrderThread = new Thread(() -> {
try {
System.out.println("正在统计订单数量");
Thread.sleep(3000);//任务执行需要3秒
map.put("countOrder", 20);//保存结果值
System.out.println("统计订单数量完毕");
countDownLatch.countDown();//标记已经完成一个任务
} catch (InterruptedException e) {
e.printStackTrace();
}
});
Thread countGoodsThread = new Thread(() -> {
try {
System.out.println("正在商品销量");
Thread.sleep(3000);//任务执行需要3秒
map.put("countGoods", 300);//保存结果值
System.out.println("统计商品销量完毕");
countDownLatch.countDown();//标记已经完成一个任务
} catch (InterruptedException e) {
e.printStackTrace();
}
});
Thread countmoneyThread = new Thread(() -> {
try {
System.out.println("正在总销售额");
Thread.sleep(3000);//任务执行需要3秒
map.put("countMoney", 40000);//保存结果值
System.out.println("统计销售额完毕");
countDownLatch.countDown();//标记已经完成一个任务
} catch (InterruptedException e) {
e.printStackTrace();
}
});
//启动子线程执行任务
countUserThread.start();
countGoodsThread.start();
countOrderThread.start();
countmoneyThread.start();
try {
//主线程等待所有统计指标执行完毕
countDownLatch.await();
long endTime = System.currentTimeMillis();//记录结束时间
System.out.println("------统计指标全部完成--------");
System.out.println("统计结果为：" + map);
System.out.println("任务总执行时间为" + (endTime - startTime) + "ms");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}使用多執行緒取代for迴圈提高查詢效率，並且防止主執行緒提前結束導致其他執行緒資料錯誤
直接上程式碼：
@Override
public AppResponse getLocations() throws InterruptedException {
List<GetLocationVO> vos = new ArrayList<>();
vos = projectDao.getLocationOne();
// 原来的代码
// for (GetLocationVO vo : vos) {
// List<LocationVO> children = projectDao.getLocationChildren(vo.getId());
// vo.setChildren(children);
// }
//改造后的代码
Thread(vos,10);
return AppResponse.success("查询成功",vos);
}
//此处有加锁
public synchronized void Thread(List<GetLocationVO> list, int nThread) throws InterruptedException {
if (CollectionUtils.isEmpty(list) || nThread <= 0 || CollectionUtils.isEmpty(list)) {
return;
}
CountDownLatch latch = new CountDownLatch(list.size());//创建一个计数器（大小为当前数组的大小，确保所有执行完主线程才结束）
ExecutorService pool = Executors.newFixedThreadPool(nThread);//创建一个固定的线程池
for (GetLocationVO vo : list) {
pool.execute(() -> {
//处理的业务
List<LocationVO> children = projectDao.getLocationChildren(vo.getId());
vo.setChildren(children);
latch.countDown();
});
}
latch.await();
pool.shutdown();
}以上是如何在Java中使用多執行緒來防止主執行緒提前結束？的詳細內容。更多資訊請關注PHP中文網其他相關文章！
