一、线程同步类属于JUC的线程同步类，这些类使得线程之间的协调更加容易，支持了丰富的线程协调场景。逐步淘汰了Object的wait()和notify()方法.

1.1 CountDownLatch类

package com.wang.thread;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * @author captain
 * @date 2020/5/6 9:13
 * 信号量同步是指在不同的线程之间，通过传递同步信号来协调线程执行的先后次序。
 * 基于时间维度：CountDownLatch
 * 基于信号维度:Semaphore
 *
 * 举例：
 *   某国际化基础语言管理平台收到多语言翻译请求，根据目标语种，拆分成多个子线程，对翻译引擎发起请求
 *   翻译完成后，同步返回给调用方，结果由于countDown()抛出异常，导致故障，警示代码如下：
 */
public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch count = new CountDownLatch(3);

        Thread thread1 = new TranslateThread("1st content",count);
        Thread thread2 = new TranslateThread("2st content",count);
        Thread thread3 = new TranslateThread("3st content",count);
        thread1.start();
        thread2.start();
        thread3.start();

        count.await(10, TimeUnit.SECONDS);

        System.out.println("执行完成！");

        // 给调用方但会结果
    }
}

class TranslateThread extends Thread{
    private String content;
    private final CountDownLatch count;

    public TranslateThread(String content, CountDownLatch count) {
        this.content = content;
        this.count = count;
    }

    @Override
    public void run() {
        // 某种情况下，翻译解析，抛出异常
        if (Math.random() > 0.5){
            throw new RuntimeException("原文存在非法字符！");
        }

        System.out.println("翻译完成，译文是。。。。。。。。。。。。");

        // 最终没有执行该方法。
        count.countDown();
    }
}

1.2 Semaphore类

package com.wang.thread;

import java.util.concurrent.Semaphore;

/**
 * @author 纸浅
 * @date 2020/5/6 9:25
 * 使用信号量同步机制 完成需求：
 *   海关安检：某机场的海关共有三个窗口，一批需要出关的人排成长队，每个人都是一个线程。
 *   当三个窗口出现任意一个空闲时候，工作人员指示独一列的第一个人出对到空闲窗口安检。
 * Semaphore：只有调用acquire()方法后才可以向下执行。
 *            执行完毕调用release()释放持有的信号量。
 *  如果某个人的身份可疑，需要确认更多的信息，这不会影响到其他窗口的安检速度。
 *  如果semaphore的窗口信号量=1，就是典型的互斥锁。
 *  提示： 安全上还有性能上，尽量使用并发包的信号量同步类，
 *        避免使用对象的wait() notify()方法来进行同步。
 */
public class CustomCheckWinow {
    public static void main(String[] args) {
        // 定义三个信号量，即3个服务窗口
        Semaphore semaphore = new Semaphore(3);

        // 排队的5个人
        for (int i = 1; i <= 5; i++) {
            new SecurityCheckThread(i, semaphore).start();
        }
    }


    private static class SecurityCheckThread extends Thread{
        private int seq;
        private Semaphore semaphore;

        public SecurityCheckThread(int seq, Semaphore semaphore){
            this.seq = seq;
            this.semaphore = semaphore;
        }

        @Override
        public void run() {
            try{
                semaphore.acquire();
                System.out.println("No."+ seq + "乘客，正在接受检查。");
                if (seq % 2 == 0){
                    Thread.sleep(3000);
                    System.out.println("No."+ seq + "乘客，身份可疑，不能出国。");
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                semaphore.release();
                System.out.println("No."+ seq + "乘客，检查完毕。");
            }
        }
    }
}