Java并发同步器--CountDownLatch

CountDownLatch（计数栓）同步器也是concurrent工具包中一个同步辅助类。主要是用来进行计数同步，完成多个子线程的等待，随后进行同时并发执行。其CountdownLatch类的构造函数原型如下：

public CountDownLatch(int count) {
    if (count < 0) throw new IllegalArgumentException("count < 0");
    this.sync = new Sync(count);
}

参数count是用来进行计数初始化 ，Sync方法也是该类中的定义，其原型如下：

Sync(int count) {
        setState(count);
    }

CountDownLatch类中主要的有await和countDown两种方法，类似于semaphore类中的acquire和release方法。定义如下：

public void await() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}
public void countDown() {
    sync.releaseShared(1);
}

acquireSharedInterruptibly和releaseShared两个方法主要是用来进行同步资源的获取和释放，这两个方法的参数均为1，并没有实际的数量意义，只是一个非零表征，说明该方法的正常调用。CountDownLatch同步器的使用如下：

package concurrent;

import java.util.concurrent.CountDownLatch;

public class TestCountDownLatch {
    public static void main(String[] args) {
        '''初始化计数值'''
        CountDownLatch countDownLatch = new CountDownLatch(3);
        '''创建三个子线程A,B,C'''
        new Work(countDownLatch, "A").start();
        new Work(countDownLatch, "B").start();
        new Work(countDownLatch, "C").start();
        for (int i = 3; i > 0; i--) {
            try {
                System.out.println(i);
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            '''用变量i记录每一次对CountDown方法的调用'''
            countDownLatch.countDown();
            if (i == 1) {
                System.out.println("start");
            }
        }
    }

}

class Work extends Thread {
    private CountDownLatch countDownLatch;

    public Work(CountDownLatch countDownLatch, String name) {
        setName(name);
        this.countDownLatch = countDownLatch;
    }

    public void run() {
        try {
            System.out.println(getName() + "is waiting");
            countDownLatch.await();
            System.out.println(getName() + "is working");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

程序的一种运行结果如下:

3
Cis waiting
Ais waiting
Bis waiting
2
1
start
Cis working
Bis working
Ais working

可以看出，新创建的三个子线程在调用await方法后都被阻塞了，知道计数器在调用个3次countDown方法后，三个子线程才可以执行。若计数器的初始值和countDown的方法调用次数不一致，会导致线程的调用紊乱。比如将计数器的初始值置为2，运行结果如下：

3
Bis waiting
Ais waiting
Cis waiting
2
Bis working
Ais working
Cis working
1
start

虽然三个子线程都得到了执行，但却失去了控制作用，在计数到2的时候就出现了程序的误运行操作。再将计数器的值初始化为4，运行结果变成：

3
Ais waiting
Bis waiting
Cis waiting
2
1
start

可以看出，由于countDown方法的调用不够，导致countDownLatch同步量资源没有被释放，也就是说，这种情况下虽然预期设置能够正常控制，但并不能使子线程正常并发进行，仍然处于阻塞。

CountDownLatch同步器一般可以用来控制多线程的并发，但并不能控制并发的数量。