线程同步器CountDownLatch

当前位置:

首页 > temp > 简明python教程 >

线程同步器CountDownLatch

　Java程序有的时候在主线程中会创建多个线程去执行任务，然后在主线程执行完毕之前，把所有线程的任务进行汇总，以前可以用线程的join方法，但是这个方法不够灵活，我们可以使用CountDownLatch类，实现更优雅,而且使用线程池的话，可没有办法调用线程的join方法的呀！

一.简单使用CountDownLatch

　　直接使用线程：

package com.example.demo.study;

import java.util.concurrent.CountDownLatch;

public class Study0215 {
    //这里相当于新建一个初始值为2的计数器
    private static volatile CountDownLatch countDownLatch = new CountDownLatch(2);
    
    public static void main(String[] args) throws InterruptedException {
        
        new Thread(()->{
            try {
                Thread.sleep(1000);
                System.out.println("线程一执行完毕");
            } catch (Exception e) {
                
            }finally {
                //每调用这个方法计数器减一
                countDownLatch.countDown();
            }
            
        }).start();
        
        new Thread(()->{
            try {
                Thread.sleep(1000);
                System.out.println("线程二执行完毕");
            } catch (Exception e) {
                
            }finally {
                countDownLatch.countDown();
            }
            
        }).start();
        
        System.out.println("两个线程已经全部启动");
        //只要调用了这个方法之后，主线程会阻塞，直到计数器countDownLatch变成0就会返回
        countDownLatch.await();
        System.out.println("执行完毕");
        
    }
    
}

　　实际中尽量少直接操作线程，而是使用线程池：

package com.example.demo.study;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Study0215 {
    // 这里相当于新建一个初始值为2的计数器
    private static volatile CountDownLatch countDownLatch = new CountDownLatch(2);

    public static void main(String[] args) throws InterruptedException {
        //创建线程池
        ExecutorService pool = Executors.newFixedThreadPool(2);
        //将任务一丢进线程池
        pool.submit(() -> {
            try {
                Thread.sleep(1000);
                System.out.println("线程一执行完毕");
            } catch (Exception e) {

            } finally {
                // 每调用这个方法计数器减一
                countDownLatch.countDown();
            }
        });
        //任务二丢进线程池
        pool.submit(() -> {
            try {
                Thread.sleep(1000);
                System.out.println("线程二执行完毕");
            } catch (Exception e) {

            } finally {
                countDownLatch.countDown();
            }
        });

        System.out.println("两个线程已经全部启动");
        // 只要调用了这个方法之后，主线程会阻塞，直到计数器countDownLatch变成0就会返回
        countDownLatch.await();
        System.out.println("执行完毕");

    }

}

二.await方法

　　看下面的图，可以知道这个CountDownLatch类内部有个工具类Sync实现了AQS，然后CountDownLatch中的方法都是调用工具类Sync去操作的，emmm....跟前面说过的ReentrantLock类结构是一样的；

　　我们看看CountDownLatch构造器传递的数其实就是设置AQS中state的值：

//实际上调用把值传递给了Sync，也就是设置了AQS中的state
public CountDownLatch(int count) {
    if (count < 0) throw new IllegalArgumentException("count < 0");
    this.sync = new Sync(count);
}
Sync(int count) {
    setState(count);
}

　　我们再看看await方法：

//当前线程调用了await方法之后，当前线程就会给阻塞，直到以下两种情况：
//1.其他线程调用了countDown方法将计数器减到0之后，该线程就返回了；
//2.其他线程调用了当前的线程的中断方法，当前线程抛出异常InterruptedException
public void await() throws InterruptedException {
    sync.acquireSharedInterruptibly(1

栏目列表