1. ReentrantLock

2. CountDownLatch

  1. import java.util.concurrent.CountDownLatch;
  4. public class TestCountDownLatch {
  5.     public static void main(String[] args) {
  6.         CountDownLatch countDownLatch = new CountDownLatch(100);
  7.         Thread[] threads = new Thread[100];
  9.         for (int i = 0; i<100; i++){
  10.             threads[i] = new Thread(()->{
  11.                 try {
  12.                     Thread.sleep(5000L);
  13.                 } catch (InterruptedException e) {
  14.                     e.printStackTrace();
  15.                 }
  16.                 countDownLatch.countDown();
  17.             });
  18.         }
  20.         for (Thread thread : threads) {
  21.             thread.start();
  22.         }
  24.         new Thread(()->{
  25.             try {
  26.                 countDownLatch.await();
  27.             } catch (InterruptedException e) {
  28.                 e.printStackTrace();
  29.             }
  30.             System.out.println("全部线程已执行完");
  31.         }).start();
  33.     }
  34. }

3. CyclicBarrier

  1. import java.util.concurrent.BrokenBarrierException;
  2. import java.util.concurrent.CyclicBarrier;
  4. public class TestCyclicBarrier {
  5.     public static void main(String[] args) {
  6.         CyclicBarrier cyclicBarrier = new CyclicBarrier(20);
  7.         for (int i = 0; i<20; i++){
  8.             int finalI = i;
  9.             new Thread(()->{
  10.                 try {
  11.                     System.out.println("线程"+ finalI +"已开始运行");
  12.                     cyclicBarrier.await();
  13.                 } catch (InterruptedException e) {
  14.                     e.printStackTrace();
  15.                 } catch (BrokenBarrierException e) {
  16.                     e.printStackTrace();
  17.                 }
  18.                 System.out.println("线程"+ finalI +"已运行结束");
  19.             }).start();
  20.         }
  21.     }
  22. }

CyclicBarrier可以用于多线程计算数据，最后合并计算结果的应用场景。比如现在需要计算10个人12个月内的工资详细，可以将线程分为10个，分别计算每个人的工资，最后，再用barrierAction将这些线程的计算结果进行整合，得出最后结果。

4. Condition

5. Phaser

https://blog.csdn.net/u010739551/article/details/51083004

  1. /**
  2.  *  下面说说Phaser的高级用法，在Phaser内有2个重要状态，分别是phase和party。
  3.  *  phase就是阶段，初值为0，当所有的线程执行完本轮任务，同时开始下一轮任务时，
  4.  *  意味着当前阶段已结束，进入到下一阶段，phase的值自动加1。party就是线程，
  5.  *  party=4就意味着Phaser对象当前管理着4个线程。Phaser还有一个重要的方法经常需要被重载，
  6.  *  那就是boolean onAdvance(int phase, int registeredParties)方法。此方法有2个作用：
  7.  *  1、当每一个阶段执行完毕，此方法会被自动调用，因此，重载此方法写入的代码会在每个阶段执行完毕时执行，
  8.  *  相当于CyclicBarrier的barrierAction。
  9.  *  2、当此方法返回true时，意味着Phaser被终止，因此可以巧妙的设置此方法的返回值来终止所有线程。
  10.  */
  11. public class MyPhaser extends Phaser {
  12.     @Override
  13.     protected boolean onAdvance(int phase, int registeredParties) {
  14.         switch (phase){
  15.             case 0:
  16.                 System.out.println(getRegisteredParties()+"个线程到达,开始考试!");
  17.                 return false;
  18.             case 1:
  19.                 System.out.println("第1题所有线程做完!");
  20.                 return false;
  21.             case 2:
  22.                 System.out.println("第2题所有线程做完!");
  23.                 return false;
  24.             case 3:
  25.                 System.out.println("第3题所有线程做完!");
  26.                 return false;
  27.             default:
  28.                 System.out.println("所有题做完, 考试结束!");
  29.                 return true;
  30.         }
  31.     }
  33.     /**
  34.      * 题目：5个学生参加考试，一共有三道题，要求所有学生到齐才能开始考试
  35.      * ，全部做完第一题，才能继续做第二题，后面类似。
  36.      *
  37.      * Phaser有phase和party两个重要状态，
  38.      * phase表示阶段，party表示每个阶段的线程个数，
  39.      * 只有每个线程都执行了phaser.arriveAndAwaitAdvance();
  40.      * 才会进入下一个阶段，否则阻塞等待。
  41.      * 例如题目中5个学生(线程)都条用phaser.arriveAndAwaitAdvance();就进入下一题
  42.      * @param args
  43.      */
  44.     public static void main(String[] args) {
  45.         MyPhaser myPhaser = new MyPhaser();
  46.         for (int i = 0; i < 5; i++ ){
  47.             new Thread(()->{
  48.                 myPhaser.register();
  49.                 System.out.println(Thread.currentThread().getName()+"已到达,准备考试");
  50.                 myPhaser.arriveAndAwaitAdvance();
  52.                 System.out.println(Thread.currentThread().getName()+"做第1题完成...");
  53.                 myPhaser.arriveAndAwaitAdvance();
  55.                 System.out.println(Thread.currentThread().getName()+"做第2题完成...");
  56.                 myPhaser.arriveAndAwaitAdvance();
  58.                 System.out.println(Thread.currentThread().getName()+"做第3题完成...");
  59.                 myPhaser.arriveAndAwaitAdvance();
  61.             },"线程"+i).start();
  62.         }
  63.     }
  64. }

运行结果：

线程0已到达,准备考试 线程3已到达,准备考试 线程2已到达,准备考试 线程1已到达,准备考试 线程4已到达,准备考试 5个线程到达,开始考试! 线程4做第1题完成… 线程2做第1题完成… 线程3做第1题完成… 线程0做第1题完成… 线程1做第1题完成… 第1题所有线程做完! 线程3做第2题完成… 线程0做第2题完成… 线程4做第2题完成… 线程1做第2题完成… 线程2做第2题完成… 第2题所有线程做完! 线程2做第3题完成… 线程1做第3题完成… 线程0做第3题完成… 线程3做第3题完成… 线程4做第3题完成… 第3题所有线程做完!

6. ReadWriteLock

  1. public class T10_TestReadWriteLock {
  3.     //写操作的值
  4.     static int i;
  6.     /**
  7.      * 模拟读操作
  8.      * @param lock
  9.      */
  10.     public static void read(Lock lock) {
  11.         try {
  12.             lock.lock();                //先获得锁
  13.             Thread.sleep(1000);   //睡眠1秒钟模拟读操作的执行时间
  14.             System.out.println("read over!");
  15.         } catch (InterruptedException e) {
  16.             e.printStackTrace();
  17.         } finally {
  18.             lock.unlock();              //释放锁
  19.         }
  20.     }
  22.     /**
  23.      * 模拟写操作
  24.      * @param lock
  25.      * @param v
  26.      */
  27.     public static void write(Lock lock, int v) {
  28.         try {
  29.             lock.lock();                //先获得锁
  30.             Thread.sleep(1000);   //睡眠1秒钟模拟写操作的执行时间
  31.             i = v;
  32.             System.out.println("write over!");
  33.         } catch (InterruptedException e) {
  34.             e.printStackTrace();
  35.         } finally {
  36.             lock.unlock();              //释放锁
  37.         }
  38.     }
  40.     /**
  41.      * 测试ReentrantLock
  42.      * @throws InterruptedException
  43.      */
  44.     public static void testReentrantLock() throws InterruptedException {
  45.         Lock lock = new ReentrantLock();
  46.         CountDownLatch countDownLatch = new CountDownLatch(20);
  47.         System.out.println("测试ReentrantLock计时开始");
  48.         long start = System.currentTimeMillis();
  49.         //18个线程读操作
  50.         for(int i=0; i<18; i++){
  51.             new Thread(()->{
  52.                 read(lock);
  53.                 countDownLatch.countDown();
  54.             }).start();
  55.         }
  56.         //2个线程写操作
  57.         for(int i=0; i<2; i++){
  58.             new Thread(()->{
  59.                 write(lock,new Random().nextInt());
  60.                 countDownLatch.countDown();
  61.             }).start();
  62.         }
  63.         countDownLatch.await();
  64.         long end = System.currentTimeMillis();
  65.         System.out.println("测试ReentrantLock计时结束,总共消耗时间:"+(end-start)/1000+"秒\n");
  66.     }
  69.     /**
  70.      * 测试ReadWriteLock
  71.      * @throws InterruptedException
  72.      */
  73.     public static void testReadWriteLock() throws InterruptedException {
  74.         //创建2把互相配合的读写锁
  75.         ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
  76.         Lock readLock = readWriteLock.readLock();    //读锁
  77.         Lock writeLock = readWriteLock.writeLock();  //写锁
  78.         CountDownLatch countDownLatch = new CountDownLatch(20);
  79.         System.out.println("测试ReadWriteLock计时开始");
  80.         long start = System.currentTimeMillis();
  81.         //18个线程读操作
  82.         for( int i = 0 ; i < 18 ; i++ ){
  83.             new Thread(()->{
  84.                 read(readLock);
  85.                 countDownLatch.countDown();
  86.             }).start();
  87.         }
  88.         //2个线程写操作
  89.         for( int i = 0 ; i < 2 ; i++){
  90.             new Thread(()->{
  91.                 write(writeLock,new Random().nextInt());
  92.                 countDownLatch.countDown();
  93.             }).start();
  94.         }
  95.         countDownLatch.await();
  96.         long end = System.currentTimeMillis();
  97.         System.out.println("测试ReadWriteLock计时结束,总共消耗时间:"+(end-start)/1000+"秒");
  98.     }
  100.     public static void main(String[] args) throws InterruptedException {
  101.         //测试ReentrantLock
  102.         testReentrantLock();
  103.         //测试ReadWriteLock
  104.         testReadWriteLock();
  105.     }
  106. }

运行结果：

测试ReadWriteLock计时开始 read over! read over! read over! read over! read over! read over! read over! read over! read over! read over! read over! read over! read over! read over! read over!

read over!

read over!

read over!

write over!

write over!

测试ReadWriteLock计时结束,总共消耗时间:3秒

测试ReentrantLock计时开始

read over!

read over!

read over!

read over!

read over!

read over!

read over!

read over!

read over!

read over!

read over!

read over!

read over!

read over!

read over!

read over!

read over!

read over!

write over!

write over!

测试ReentrantLock计时结束,总共消耗时间:20秒

7. Semaphore

Semaphore是一个线程同步的辅助类，可以维护当前访问自身的线程个数，并提供了同步机制。使用Semaphore可以控制同时访问资源的线程个数。
Semaphore的主要方法摘要：

void acquire() 从此信号量获取一个许可，在提供一个许可前一直将线程阻塞，否则线程被中断。
void release() 释放一个许可，将其返回给信号量。
int availablePermits() 返回此信号量中当前可用的许可数。
boolean hasQueuedThreads() 查询是否有线程正在等待获取。 
  1. import java.util.concurrent.Semaphore;
  3. /**
  4.  * 模拟多线程去操作资源.
  5.  * 假设有10个线程需要访问同一个文件资源, 由于文件资源做大能读取的线程是3,所以同时只能有3个线程访问这个文件. 我们使用Semaphore来控制
  6.  */
  7. public class T11_TestSemaphore {
  8.     //3个信号灯,只允许3个线程同时执行
  9.     static Semaphore semaphore = new Semaphore(3);
  10.     public static void main(String[] args) {
  11.         for ( int i = 1; i <= 10; i++ ){
  12.             int j = i;
  13.             new Thread(()->{
  14.                 try {
  15.                     System.out.println("第"+ j +"个线程来了.." );
  16.                     semaphore.acquire();
  17.                     System.out.println("第"+ j +"个线程拿到了许可证,开始访问");
  18.                     Thread.sleep(10000L);
  19.                     System.out.println("第"+ j +"个线程访问完毕");
  20.                 } catch (InterruptedException e) {
  21.                     e.printStackTrace();
  22.                 } finally {
  23.                     System.out.println("第"+ j +"个线程释放了许可证");
  24.                     semaphore.release();
  25.                 }
  26.             }).start();
  27.         }
  28.     }
  29. }

运行结果：

第1个线程来了..

第4个线程来了..

第1个线程拿到了许可证,开始访问

第3个线程来了..

第3个线程拿到了许可证,开始访问

第2个线程来了..

第7个线程来了..

第6个线程来了..

第4个线程拿到了许可证,开始访问

第5个线程来了..

第8个线程来了..

第9个线程来了..

第10个线程来了..

第1个线程访问完毕

第1个线程释放了许可证

第3个线程访问完毕

第3个线程释放了许可证

第2个线程拿到了许可证,开始访问

第7个线程拿到了许可证,开始访问

第4个线程访问完毕

第4个线程释放了许可证

第6个线程拿到了许可证,开始访问

第2个线程访问完毕

第2个线程释放了许可证

第7个线程访问完毕

第5个线程拿到了许可证,开始访问

第7个线程释放了许可证

第8个线程拿到了许可证,开始访问

第6个线程访问完毕

第6个线程释放了许可证

第9个线程拿到了许可证,开始访问

第5个线程访问完毕

第5个线程释放了许可证

第8个线程访问完毕

第8个线程释放了许可证

第9个线程访问完毕

第9个线程释放了许可证

第10个线程拿到了许可证,开始访问

第10个线程访问完毕

第10个线程释放了许可证

8. Exchanger

  1. import java.util.concurrent.Exchanger;
  3. public class TestExchanger {
  5.     static Exchanger<String> exchanger = new Exchanger<>();
  7.     public static void main(String[] args) {
  8.         new Thread(()->{
  9.             try {
  10.                 String t1Str = "T1";
  11.                 System.out.println("t1线程的变量为 "+t1Str+", 开始交换..");
  12.                 t1Str = exchanger.exchange(t1Str);
  13.                 System.out.println("t1线程交换后的变量为"+t1Str);
  14.             } catch (InterruptedException e) {
  15.                 e.printStackTrace();
  16.             }
  17.         }, "t1").start();
  19.         new Thread(()->{
  20.             try {
  21.                 String t2Str = "T2";
  22.                 System.out.println("t2线程的变量为 "+t2Str+", 开始交换..");
  23.                 t2Str = exchanger.exchange(t2Str);
  24.                 System.out.println("t2线程交换后的变量为"+t2Str);
  25.             } catch (InterruptedException e) {
  26.                 e.printStackTrace();
  27.             }
  28.         }, "t2").start();
  29.     }
  30. }

运行结果：

t1线程的变量为 T1, 开始交换..

t2线程的变量为 T2, 开始交换..

t2线程交换后的变量为T1

t1线程交换后的变量为T2

9. LockSupport

**

10. 多线程面试题

10.1 线程监测题

题目：

创建2个线程，第1个线程往集合里面装10个对象， 第二个线程检测第一个线程装满5个时打印。

wait 和 notify 配合

  2. public class WaitAndNotify {
  3.     public static void main(String[] args) throws InterruptedException {
  4.         //创建一个对象用来锁
  5.         Object o = new Object();
  6.         //元素集合
  7.         ArrayList<Object> arrayList = new ArrayList<>();
  9.         new Thread(()->{
  10.             synchronized (o){
  11.                 System.out.println("线程2启动...");
  12.                 try {
  13.                     o.wait();
  14.                 } catch (InterruptedException e) {
  15.                     e.printStackTrace();
  16.                 }
  17.                 System.out.println("线程2检测到线程1收集了5个元素");
  18.                 o.notify();
  19.             }
  20.         }).start();
  22.         //睡眠1秒是为了保证线程2能先启动并等待。
  23.         TimeUnit.SECONDS.sleep(1);
  25.         new Thread(()->{
  26.             synchronized (o){
  27.                 System.out.println("线程1启动...");
  28.                 for (int i = 0; i < 10; i++) {
  29.                     System.out.println("线程1收集第"+i+"个对象");
  30.                     arrayList.add(new Object());
  31.                     if ( arrayList.size() == 5 ){
  32.                         try {
  33.                             o.notify();
  34.                             o.wait();
  35.                         } catch (InterruptedException e) {
  36.                             e.printStackTrace();
  37.                         }
  38.                     }
  39.                     o.notify();
  40.                 }
  41.             }
  42.         }).start();
  43.     }
  44. }

使用**LockSupport**

  1. public class WithLockSupport {
  3.     static Thread t1 = null, t2 = null;
  5.     public static void main(String[] args) throws InterruptedException {
  6.         //创建一个对象用来锁
  7.         Object o = new Object();
  8.         //元素集合
  9.         ArrayList<Object> arrayList = new ArrayList<>();
  11.         t2 = new Thread(()->{
  12.             System.out.println("线程2启动...");
  13.             LockSupport.park();
  14.             System.out.println("线程2检测到线程1收集了5个元素");
  15.             LockSupport.unpark(t1);
  16.         });
  18.         t1 = new Thread(() -> {
  19.             System.out.println("线程1启动...");
  20.             for (int i = 0; i < 10; i++) {
  21.                 arrayList.add(new Object());
  22.                 System.out.println("线程1收集第"+i+"个对象");
  23.                 if (arrayList.size() == 5){
  24.                     LockSupport.unpark(t2);
  25.                 }
  26.             }
  27.         });
  29.         t2.start();
  30.         TimeUnit.SECONDS.sleep(1);
  31.         t1.start();
  33.     }
  35. }

使用CountDownLatch

  1. public class WithCountDownLatch {
  3.     static Thread t1 = null, t2 = null;
  5.     public static void main(String[] args) throws InterruptedException {
  6.         //创建一个对象用来锁
  7.         Object o = new Object();
  8.         //元素集合
  9.         ArrayList<Object> arrayList = new ArrayList<>();
  11.         CountDownLatch t1Latch = new CountDownLatch(1);
  12.         CountDownLatch t2Latch = new CountDownLatch(1);
  14.         t2 = new Thread(()->{
  15.             System.out.println("线程2启动...");
  16.             try {
  17.                 t2Latch.await();
  18.             } catch (InterruptedException e) {
  19.                 e.printStackTrace();
  20.             }
  21.             System.out.println("线程2检测到线程1收集了5个元素");
  22.             t1Latch.countDown();
  23.         });
  25.         t1 = new Thread(() -> {
  26.             System.out.println("线程1启动...");
  27.             for (int i = 0; i < 10; i++) {
  28.                 arrayList.add(new Object());
  29.                 System.out.println("线程1收集第"+i+"个对象");
  30.                 if (arrayList.size() == 5){
  31.                     t2Latch.countDown();
  32.                     try {
  33.                         t1Latch.await();
  34.                     } catch (InterruptedException e) {
  35.                         e.printStackTrace();
  36.                     }
  37.                 }
  38.             }
  39.         });
  41.         t2.start();
  42.         TimeUnit.SECONDS.sleep(1);
  43.         t1.start();
  45.     }
  46. }

10.2 交叉打印题

有2个线程， 线程1打印数组内的元素[1,2,3,4,5,6]， 线程2打印数组内元素[‘A’,’B’,’C’,’D’,’E’,’F’]， 现在要求两个数组在控制台交叉打印元素， 最终打印的结果显示为：1A2B3C4D5E6F

  1. public class TestCrossPrint {
  3.     //线程1需要打印的数组
  4.     public static int[] intArr = new int[]{1,2,3,4,5,6};
  5.     //线程2需要打印的数组
  6.     public static char[] charArr = new char[]{'A','B','C','D','E','F'};
  7.     //需要一个对象来当做锁
  8.     static Object o = new Object();
  10.     public static void main(String[] args) throws InterruptedException {
  11.         Thread t1 = null, t2 = null;
  12.         t1 = new Thread(()->{
  13.             synchronized (o){
  14.                 for (int i : intArr) {
  15.                     System.out.print(i);
  16.                     try {
  17.                         o.notify();
  18.                         o.wait();
  19.                     } catch (InterruptedException e) {
  20.                         e.printStackTrace();
  21.                     }
  22.                 }
  23.             }
  24.         });
  26.         t2 = new Thread(()->{
  27.             synchronized (o){
  28.                 for (char c : charArr) {
  29.                     try {
  30.                         o.wait();
  31.                     } catch (InterruptedException e) {
  32.                         e.printStackTrace();
  33.                     }
  34.                     System.out.print(c);
  35.                     o.notify();
  36.                 }
  37.             }
  38.         });
  40.         t2.start();
  41.         //保证线程2比线程1线启动之心并等待.
  42.         TimeUnit.SECONDS.sleep(1);
  43.         t1.start();
  44.     }
  45. }

10.3 生产者消费者线程

写一个固定容量的同步容器， 有 get、set、getCount三个方法，能够支持2个生产者线程生产固定容量的元素和10个消费者线程不断地阻塞调用消费。
synchronized版:

  1. import java.util.LinkedList;
  2. import java.util.List;
  3. import java.util.concurrent.TimeUnit;
  5. /**
  6.  *写一个固定容量的同步容器， 有 get、set、getCount三个方法，能够支持2个生产者线程生产固定容量的元素和10个消费者线程不断地阻塞调用消费。
  7.  * synchronized版
  8.  */
  9. public class MyContainer<T> {
  11.     //使用链表来模拟容器
  12.     private final LinkedList<T> container = new LinkedList<T>();
  13.     //容器没最大元素数量
  14.     private static final int  MAX = 10;
  15.     //容器内挡墙元素数量
  16.     private int count = 0;
  18.     /**
  19.      * 存储元素
  20.      * @param t
  21.      * @throws InterruptedException
  22.      */
  23.     public void put(T t) throws InterruptedException {
  24.         synchronized (this){
  25.             //为什么这里是while而不是if？ 因为wait时可能会被非消费者线程线程唤醒。notifyAll？
  26.             while (this.container.size() == MAX ){
  27.                 this.wait();
  28.             }
  29.             this.container.add(t);  //集合内添加元素
  30.             count++;                //元素数量+1
  31.             this.notifyAll();       //通知消费者进行消费
  32.         }
  33.     }
  35.     /**
  36.      * 从头部删除一个元素
  37.      * @return
  38.      * @throws InterruptedException
  39.      */
  40.     public T get() throws InterruptedException {
  41.         synchronized (this){
  42.             //为什么这里是while而不是if?  因为wait时可能会被非生产者线程线程唤醒。notifyAll？
  43.             while (this.container.size() == 0){
  44.                 this.wait();
  45.             }
  46.             T t = this.container.removeFirst(); //删除头部的一个元素
  47.             this.count--;                       //集合内元素数量-1
  48.             this.notifyAll();                   //通知生产者进行生产
  49.             return t;
  50.         }
  51.     }
  53.     /**
  54.      * 获取元素数量。
  55.      * @return
  56.      */
  57.     public int getCount(){
  58.         return this.count;
  59.     }
  61.     //测试
  62.     public static void main(String[] args) throws InterruptedException {
  63.         MyContainer<Integer> myContainer = new MyContainer<>();
  65.         //启动10个消费者进行消费
  66.         for (int i = 0; i < 10; i++) {
  67.             new Thread(()->{
  68.                 for (int j = 0; j < 5; j++) {
  69.                     try {
  70.                         System.out.println(myContainer.get());
  71.                     } catch (InterruptedException e) {
  72.                         e.printStackTrace();
  73.                     }
  74.                 }
  75.             }).start();
  76.         }
  78.         //睡眠2秒钟，保证消费者线程先启动。
  79.         TimeUnit.SECONDS.sleep(2);
  81.         //启动2个生产者线程进行生产
  82.         for (int i = 0; i < 2; i++) {
  83.             new Thread(()->{
  84.                 for (int j = 0; j < 25; j++) {
  85.                     try {
  86.                         myContainer.put(j);
  87.                     } catch (InterruptedException e) {
  88.                         e.printStackTrace();
  89.                     }
  90.                 }
  91.             }).start();
  92.         }
  94.     }
  95. }

Condition版:

  1. import java.util.LinkedList;
  2. import java.util.concurrent.TimeUnit;
  3. import java.util.concurrent.locks.Condition;
  4. import java.util.concurrent.locks.Lock;
  5. import java.util.concurrent.locks.ReentrantLock;
  7. /**
  8.  *写一个固定容量的同步容器， 有 get、set、getCount三个方法，能够支持2个生产者线程生产固定容量的元素和10个消费者线程不断地阻塞调用消费。
  9.  * Condition版
  10.  */
  11. public class MyContainer1<T> {
  13.     //使用链表来模拟容器
  14.     private final LinkedList<T> container = new LinkedList<T>();
  15.     //容器没最大元素数量
  16.     private static final int  MAX = 10;
  17.     //容器内挡墙元素数量
  18.     private int count = 0;
  19.     //可重入锁
  20.     private Lock lock = new ReentrantLock();
  21.     private Condition producter = lock.newCondition();  //生产者线程队列
  22.     private Condition consumer  = lock.newCondition();  //消费者线程队列
  24.     /**
  25.      * 存储元素
  26.      * @param t
  27.      * @throws InterruptedException
  28.      */
  29.     public void put(T t) {
  30.         this.lock.lock();      //锁定
  31.         try {
  32.             //满了就等一等，等待消费者线程消费了元素后唤醒此线程
  33.             while ( this.container.size() == MAX ){
  34.                 this.producter.await();
  35.             }
  36.             this.container.add(t);       //集合内添加元素
  37.             this.count++;                //元素数量+1
  38.             this.consumer.signalAll();   //唤醒消费者线程进程消费
  39.         }catch (Exception e){
  40.             e.printStackTrace();
  41.         }finally {
  42.             this.lock.unlock();//解锁
  43.         }
  44.     }
  46.     /**
  47.      * 从头部删除一个元素
  48.      * @return
  49.      * @throws InterruptedException
  50.      */
  51.     public T get() {
  52.         this.lock.lock();   //锁定
  53.         T t = null;
  54.         try {
  55.             //没有了就等一等，等待生产者生产了之后唤醒此线程
  56.             while (this.container.size() == 0){
  57.                 this.consumer.await();
  58.             }
  59.             t = this.container.removeFirst();   //删除头部的一个元素
  60.             this.count--;                       //集合内元素数量-1
  61.             this.producter.signalAll();         //唤醒生产者线程进行生产
  62.         }catch (Exception e){
  63.             e.printStackTrace();
  64.         }finally {
  65.             this.lock.unlock();//解锁
  66.             return t;
  67.         }
  68.     }
  70.     /**
  71.      * 获取元素数量。
  72.      * @return
  73.      */
  74.     public int getCount(){
  75.         return this.count;
  76.     }
  78.     //测试
  79.     public static void main(String[] args) throws InterruptedException {
  80.         MyContainer1<Integer> myContainer = new MyContainer1<>();
  82.         //启动10个消费者进行消费
  83.         for (int i = 0; i < 10; i++) {
  84.             new Thread(()->{
  85.                 for (int j = 0; j < 5; j++) { 
  86.                     System.out.println(myContainer.get());
  87.                 }
  88.             }).start();
  89.         }
  91.         //睡眠2秒钟，保证消费者线程先启动。
  92.         TimeUnit.SECONDS.sleep(2);
  94.         //启动2个生产者线程进行生产
  95.         for (int i = 0; i < 2; i++) {
  96.             new Thread(()->{
  97.                 for (int j = 0; j < 25; j++) {
  98.                     myContainer.put(j);
  99.                 }
  100.             }).start();
  101.         }
  103.     }
  104. }

11. AQS

AQS时Java的一个抽象类，全称为（AbstractQueuedSynchronizer）抽象队列同步器，它的包路径为**java.util.concurrent.locks.AbstractQueuedSynchronizer**，是除了java自带的synchronized关键字之外的锁机制。

AQS的核心思想是：如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并将共享资源设置为锁定状态，如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中。

CLH（Craig，Landin，and Hagersten）队列是一个虚拟的双向队列，虚拟的双向队列即不存在队列实例，仅存在节点之间的关联关系。

AQS是将每一条请求共享资源的线程封装成一个CLH锁队列的一个结点（Node），来实现锁的分配。**

用大白话来说，AQS 的 底层实现是CLH队列+volatile修饰的共享变量state，线程通过CAS去尝试改变state，成功则获取锁，失败则进入等待队列，等待被唤醒。

**注意：AQS是自旋锁：**在等待唤醒的时候，经常会使用自旋while(!cas())的方式，不停地尝试获取锁，直到被其他线程获取成功在等待唤醒的时候，经常会使用自旋while(!cas())的方式，不停地尝试获取锁，直到被其他线程获取成功

实现了AQS的锁有：自旋锁、互斥锁、读锁写锁、条件产量、信号量、栅栏都是AQS的衍生物

AQS实现的具体方式如下：
6. java多线程工具类 - 图1

如图示，AQS维护了一个volatile int state 的变量和线程等待队列,这个队列里面装的是每一个等待的线程，多线程争用资源被阻塞的时候就会进入这个队列。state就是共享资源，其访问方式有如下三种：
getState(); ： 获得状态
setState(); : 设置状态
compareAndSetState(); : CAS的方式设置状态

AQS 定义了两种资源共享方式：

  1. Exclusive：独占/排他，只有一个线程能执行，如ReentrantLock类
  2. Share：共享，多个线程可以同时执行，如Semaphore、CountDownLatch、ReadWriteLock，CyclicBarrier

不同的自定义的同步器争用共享资源的方式也不同。

AQS底层使用了模板方法模式

同步器的设计是基于模板方法模式的，如果需要自定义同步器一般的方式是这样（模板方法模式很经典的一个应用）：

  1. 使用者继承AbstractQueuedSynchronizer并重写指定的方法。（这些重写方法很简单，无非是对于共享资源state的获取和释放）
  2. 将AQS组合在自定义同步组件的实现中，并调用其模板方法，而这些模板方法会调用使用者重写的方法。
    这和我们以往通过实现接口的方式有很大区别，这是模板方法模式很经典的一个运用。

自定义同步器在实现的时候只需要实现共享资源state的获取和释放方式即可，至于具体线程等待队列的维护，AQS已经在顶层实现好了。自定义同步器实现的时候主要实现下面几种方法：

isHeldExclusively() 该线程是否正在独占资源。只有用到condition才需要去实现它。
tryAcquire(int) 独占方式。尝试获取资源，成功则返回true，失败则返回false。
tryRelease(int) 独占方式。尝试释放资源，成功则返回true，失败则返回false。
tryAcquireShared(int) 共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
tryReleaseShared(int) 共享方式。尝试释放资源，如果释放后允许唤醒后续等待结点返回true，否则返回false。

独占锁以**ReentrantLock**为例：
state初始化为0，表示未锁定状态，A线程调用lock()时，会调用tryAcquire()独占锁并将state+1.之后其他线程再想tryAcquire的时候就会失败，直到A线程unlock() s时state-1 这时 stata=0，其他线程才有机会获取该锁。A释放锁之前，自己也是可以重复获取此锁（state累加），这就是可重入的概念。
注意：获取多少次锁就要释放多少次锁，保证state是能回到零态的。只要stats回到0状态其他线程就能尝试获取锁。

共享锁以**CountDownLatch**为例：
任务分n个子线程去执行，state就初始化为n，n个线程并行执行，每个线程执行完之后countDown() 一次时state就会compareAndSetState的方式 -1。当n子线程全部执行完毕后state=0，会unpark()主调用线程，主调用线程就会从await()函数返回，继续之后的动作。
一般来说，自定义同步器要么是独占方法，要么是共享方式，他们也只需实现tryAcquire -> tryRelease或tryAcquireShared -> tryReleaseShared中的一种即可。但AQS也支持自定义同步器同时实现独占和共享两种方式，如**ReentrantReadWriteLock**。
　在acquire() 和 acquireShared()两种方式下，线程在等待队列中都是忽略中断的，acquireInterruptibly()/acquireSharedInterruptibly()是支持响应中断的。

AQS的简单应用**
Mutex：不可重入互斥锁，锁资源（state）只有两种状态：0：未被锁定；1：锁定。

AQS源码：
VarHandle

  1. 普通变量可以原子性
  2. 比反射快，直接操作二进制。