Java并发工具包学习

java并发工具包：java.util.concurrent

第一节课：同步器
1－1：Semaphore & CountDownLatch

Semaphore

Semaphore的理解：在多线程中，可将每个线程的操作视为需要一个凭证才可执行的单元。Semaphore就是提供这样一个证明的量。它提供两个方法，acquire() 和 release()方法来获取凭证和释放凭证。通过构造函数来设定允许同时发放的凭证个数。我们用代码来解释一下：

*例子以银行的服务窗口为案例：
我们用Semaphore的凭证数量来代表服务窗口的数量。

public class SemaphoreDemo {
    public static void main(String[] args) {
        //设定有2个窗口
        Semaphore semaphore = new Semaphore(2);
        //设定同时有三个人来银行请求服务
        new Person(semaphore, "A").start();
        new Person(semaphore, "B").start();
        new Person(semaphore, "C").start();
    }
}

//需要服务的人员
class Person extends Thread {
    private Semaphore semaphore;

    public Person(Semaphore semaphore, String name) {
        setName(name);
        this.semaphore = semaphore;
    }

    public void run() {
        try {
            System.out.println(getName() + " is waiting....");
            this.semaphore.acquire();
            System.out.println(getName() + " is servicing...");
            Thread.sleep(1000);
            System.out.println(getName() + " is done!");
            this.semaphore.release();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

此段代码的运行结果如下：

B is waiting....
C is waiting....
A is waiting....
C is servicing...
B is servicing...
C is done!
B is done!
A is servicing...
A is done!

虽然因为线程的运行顺序是不确定的，但是我们从结果还是可以看出，A实在CB线程结束并且释放了凭证之后才开始运行的。实际上，只要CB中任意一个线程结束后将凭证释放出来，A即可运行。大家可以调整一下每个线程的运行时间就可以看出来。

CountDownLatch

CountDownLatch的理解：直译过来就是计数拴，就好像赛跑之前要倒计时一样，当计数器到达一定条件后，线程才开始执行。
我们就以赛跑的例子来用代码演示一下经典的计数拴时如何使用的：

public class CountDownLatchDemo {

    public static void main(String[] args) {
        //假设比赛需要倒计时3秒
        CountDownLatch countDownLatch = new CountDownLatch(3);

        //构建三个参与者
        new Runner(countDownLatch, "A ").start();
        new Runner(countDownLatch, "B ").start();
        new Runner(countDownLatch, "C ").start();

        for (int i = 0; i < 3; i++) {
            System.out.println("count down :" + (3 - i));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            countDownLatch.countDown();
        }
    }
}

class Runner extends Thread {
    private CountDownLatch countDownLatch;

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


    public void run() {
        try {
            System.out.println(getName() + "is ready");
            countDownLatch.await();
            System.out.println(getName() + "is running");
            System.out.println(getName() + "is done!");
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

以上代码的输出结果如下：

A is ready
B is ready
C is ready
count down :3
count down :2
count down :1
A is running
A is done!
C is running
B is running
B is done!
C is done!

我们可以看到，三个运动员依次就绪之后都在等待。计数拴开始倒计时，完成3秒的倒计时后，线程开始运行。