【多线程】util.concurrent 使用

AQS系列一ReentrantLock的源码--aqs加锁过程
 JUC AQS ReentrantLock源码分析（一）
Java最全锁剖析：独享锁/共享锁+公平锁/非公平锁+乐观锁/悲观锁

Interfaces

在多个线程交替执行的情况，也就是没有竞争的情况下，仅在JDK级别解决同步问题，ReentrantLock不需要用到操作系统的API；
但是1.6之前的synchronized关键字在没有竞争的情况下，也会使用操作系统的API，所以ReentrantLock在这一点上的性能是优于synchronized的。
1.6之后的synchronized关键字做了优化。。。。
ReentrantLock相比于synchronized有更加丰富的API，对所锁的操作更灵活。

1、Lock、Condition基本使用

多线程编程套路

1、在高内聚低耦合的前提下，线程操作(资源类对外暴露的方法) 资源类
2、判断、干活、通知
3、多线程交互中，必须防止多线程的虚假唤醒，即判断只能用while不能用if
4、标志位

//多个线程之间顺序调用A->B
//2个线程启动，要求如下
//A打印1次，B打印2次，循环10次，ABBABBABBABBABB。。。
    private int mark=1;//标志位: 1A,2B
    Lock lock =new ReentrantLock();
    Condition conditionA=lock.newCondition();
    Condition conditionB=lock.newCondition();

    public void print1A(){
        lock.lock();
        try {
            //1、判断
            while(mark!=1){
                conditionA.await();
            }
            //2、干活
            for(int i=0;i<1;i++){
                System.out.println(Thread.currentThread().getName() +" "+ i );
            }
            //3、通知
            mark=2;
            conditionB.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void print2B(){
        lock.lock();
        try {
            while(mark!=2){
                conditionB.await();
            }
            for(int i=0;i<2;i++){
                System.out.println(Thread.currentThread().getName() +" "+ i );
            }
            mark=1;
            conditionC.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

2、ReadWriteLock

ReentrantReadWriteLock能够达到读读共享，写写互斥，读写互斥，既保证线程安全又提高效率。
多个线程可以同时进行读操作。

3、CountDownLatch

在多线程协作完成业务功能时，有时候需要等待其他多个线程完成任务之后，主线程才能继续往下执行业务功能，在这种的业务场景下，通常可以使用Thread类的join方法，让主线程等待被join的线程执行完之后，主线程才能继续往下执行。当然，使用线程间消息通信机制也可以完成。其实，java并发工具类中为我们提供了类似“倒计时”这样的工具类，可以十分方便的完成所说的这种业务场景。
链接：https://www.jianshu.com/p/03f5d1b02bb8

一个线程(或者多个)，等待另外N个线程完成某个事情之后才能执行。
CountDownLatch主要有两个方法，当一个或多个线程调用await方法时，这些线程会阻塞。
其它线程调用countDown方法会将计数器减1(调用countDown方法的线程不会阻塞)，
当计数器的值变为0时，因await方法阻塞的线程会被唤醒，继续执行。

一个面试题：10个线程，如何实现和主线程的同步？
场景是：10个人在山下聚齐之后才可以一起爬山，怎么实现？不用synchronized关键字、volatile等同步的关键字。

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(10);

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "\t到达");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                countDownLatch.countDown();
            }, String.valueOf(i)).start();
        }
        countDownLatch.await();
        System.out.println("可以爬山了");
    }

4、CyclicBarrier

一种同步辅助工具，它允许一组线程全部互相等待以到达一个公共的障碍点。
The barrier is called cyclic 因为它可以在等待的线程被释放之后重新使用。

CyclicBarrier有两个构造函数

public CyclicBarrier(int parties)
public CyclicBarrier(int parties, Runnable barrierAction)

第一个参数parties，表示barrier触发需要的线程数量。
第二个参数barrierAction，当barrier触发时所执行的操作。

一个CyclicBarrier，以展示CyclicBarrier的基本用法。
导游等1,2,3游客都到达了，再发放工具；1,2,3游客都拿好工具之后，一起出发。
为了方便展示，只使用了都写在了main函数中，只写了一个CyclicBarrier，这也能体现出CyclicBarrier被重新使用了。

  public static void main(String[] args) throws InterruptedException {
        AtomicInteger person = new AtomicInteger();
        AtomicInteger tool = new AtomicInteger();
        CyclicBarrier cyclicBarrier = new CyclicBarrier(3, () -> {
            if (person.intValue() == 3 && tool.intValue() < 3) System.out.println("发登山工具了");
            if (person.intValue() == 3 && tool.intValue() == 3) System.out.println("走吧，大家出发吧！");
        });

        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                try {
                    //人到了，加1，等待
                    System.out.println(Thread.currentThread().getName() + "达到");
                    person.getAndIncrement();
                    cyclicBarrier.await();

                    //等都领到工具了，再出发
                    System.out.println(Thread.currentThread().getName() + "拿到工具了");
                    tool.getAndIncrement();
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }, String.valueOf(i)).start();
            Thread.sleep(1000);
        }
    }

输出：
0达到
1达到
2达到
发登山工具了
2拿到工具了
0拿到工具了
1拿到工具了
走吧，大家出发吧！

5、CyclicBarrier和CountDownLatch的区别

CountDownLatch是一个（组）线程等待另一组线程执行完成并且调用countDown()达到一定数量后，自己这一组线程才继续执行。
CyclicBarrier是自己这一组线程，等待大家执行到await()，自己这一组线程再继续执行。
CountDownLatch的计数器只能使用一次。而CyclicBarrier的计数器可以使用reset() 方法重置。所以CyclicBarrier能处理更为复杂的业务场景，比如如果计算发生错误，可以重置计数器，并让线程们重新执行一次。