【Java并发解析】控制并发流程与AQS

什么是控制并发流程

控制线程执行的顺序，实现线程之间的相互配合。

常见的并发控制工具类

CountDownLatch

倒数门闩，达到一定的数量才可以执行。在倒数结束之前，线程都在等待。

• 构造方法：CountDownLatch countDownLatch = new CountDownLatch(5);参数表示几个倒计时量。
• 实例方法：
  1. .await():调用这个方法的线程会被挂起，直到count值为0。可以在主线程使用，等待子线程完成。
  2. .countDown()：将count值减1，直到为0，等待的线程被唤醒。
• 典型用法：
  1. 一个线程等待多个线程都执行完毕，在继续自己的工作。 如，主线程等子线程都完成预处理。
  2. 多个线程等待一个线程的信号，同时开始执行。 如，模拟压测，同时给服务器压力。只有一个信号，提前初始完毕全部的子线程，利用await()方法全部等待，直到主线程发令。
• 注意点: 这个类是不可以重用的，无法重置。

Semaphore

信号量用来限制和管理数量有限的资源的使用。证书的数量有限，类似于令牌。可以现实流量。

• 构造：Semaphore semaphore = new Semaphore(3, true);

• 使用流程

  1. 初始化信号量，给定指定数量的信号量，是否公平策略，一般设置为公平。
  2. 在需要被限制的代码前调用实例方法acquire()或者acquireUniterruptibly()或者tryAcquire()会返回一个布尔值 。看看有无信号量，如果获取不到，线程会等待。(acquire()方法没有参数时默认一个，但是也可以传入参数实现多个信号量的要求。)
  3. 调用完成之后，调用实例方法release()方法释放。一定要归还

• 信号量不一定要线程A获取，线程A释放

Condition

多了一些线程阻塞的条件，原来的wait()只有一个条件，现在可以设计多个。

• 构造: 这个略有不同。

        ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();

• 实例方法：condition.await()线程被阻塞，condition.signalAll()唤醒全部正在等待的线程，signal()具有公平性，唤起等待时间最长的那个线程。

• 编写生产者消费者模式：

import java.util.PriorityQueue;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Demo{
    private int queueSize = 10;
    private PriorityQueue<Integer> queue = new PriorityQueue<Integer>(queueSize);
    private Lock lock = new ReentrantLock();
    private Condition notFull = lock.newCondition();
    private Condition notEmpty = lock.newCondition();

    public static void main(String[] args) {
        Demo demo = new Demo();
        Concumer concumer = demo.new Concumer ();
        Producer producer = consumerdemo.new Producer();
        Thread t1 = new Thread(concumer);
        Thread t2 = new Thread(producer);
        t1.start();
        t2.start();

    }

    class Concumer implements Runnable{

        @Override
        public void run() {
            try {
                consume();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        private  void consume() throws InterruptedException {
            while(true){
                lock.lock();
                try {
                    while(queue.size() == 0){
                        System.out.println("empty");
                        try {
                            notEmpty.await();
                        }catch (InterruptedException e){
                            e.printStackTrace();
                        }
                    }
                    queue.poll();
                    notFull.signalAll();
                    System.out.println("get and leave"+queue.size());
                }finally {
                    lock.unlock();
                }
            }
        }
    }

    class Producer implements Runnable{

        @Override
        public void run() {
            try {
                preduce();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        private  void preduce() throws InterruptedException {
            while(true){
                lock.lock();
                try {
                    while(queue.size() == queueSize){
                        System.out.println("full");
                        try {
                            notFull.await();
                        }catch (InterruptedException e){
                            e.printStackTrace();
                        }
                    }
                    queue.offer(1);
                    notEmpty.signalAll();
                    System.out.println("make and leave"+queue.size());
                }finally {
                    lock.unlock();
                }
            }
        }
    }
}

CyclicBarrier

将大量线程相互配合，汇合之后再继续执行，

• 构造：传入的参数是需要等待的对象和Runnable接口，可以在完成集和之后进行一些操作。

        CyclicBarrier cyclicBarrier = new CyclicBarrier(5, new Runnable() {
            @Override
            public void run() {
                System.out.println("集合");
            }
        });

• 实例方法：cyclicBarrier.await()方法让先完成的线程等待。只要等待的个数达到规定的数量，就继续执行。需要注意的话，这个方法是可以重用的，也就是只要等待满足5个就可以继续执行。
• 与countdownlatch的不同：本工具针对线程，count针对的是事件，只要是某个事件发生了就可以。 并且本工具有功能。

AQS（AbstractQueueSynchronizer）

其实被广泛的应用，ReentrantLock和Semaphore，CountDownLatch等都继承了AQS类。实现了包括，同步状态的原子性管理，线程的阻塞和接触阻塞，队列的管理等。可以认为是一个构造工具类的工具类。

三大核心部分之state

state的具体含义在不同的实现类中不同，比如在Semaphore中，表示剩余的许可证数量，在CountDownLatch中表示还需要倒数的数量。ReentrantLock中表示了锁的可重入数量，为0表示当前锁是释放的。

是用volatile修饰的，会被并发的修改，因此需要保证线程安全。

三大核心部分之FIFO队列

用于存放等待的线程，维护一个等待的线程队列，把所有线程都挂起并放在这个队列里。双向链表的结构

三大核心部分之获取/释放

• 获取方法：获取操作时依赖state变量的， 经常会阻塞。都会用到CAS
• 释放方法：不会阻塞线程，操作state。也会用到CAS