13分钟聊聊并发包中常用同步组件并手写一个自定义同步组件 ...

前言

上篇文章10分钟从源码级别搞懂AQS（AbstractQueuedSynchronizer）说到JUC并发包中的同步组件大多使用AQS来实现
本篇文章通过AQS自己来实现一个同步组件，并从源码级别聊聊JUC并发包中的常用同步组件
本篇文章需要的前置知识就是AQS，如果不了解AQS的同学可以看上一篇文章哈~
阅读本篇文章大概需要13分钟
自定义同步组件

为了更容易理解其他同步组件，我们先来使用AQS自己来实现一个常用的可重入锁
AQS模板方法流程是固定的，我们主要只需要来实现它的尝试获取同步状态和尝试释放同步状态方法即可
首先我们先规定要实现的可重入锁是独占式的
规定同步状态一开始为0，当有线程获取锁成功同步状态就为1，当这个线程重入时就累加同步状态
规定释放同步状态时每次扣减1个同步状态，只有当同步状态扣减到0时，才是真正的释放独占锁
我们使用一个内部类Sync 来继承AQS 并重写tryAcquire尝试获取同步状态、tryRelease 尝试释放同步状态、isHeldExclusively判断当前线程是否持有同步状态（等待、通知时会用到该方法）

1.         static class Sync extends AbstractQueuedSynchronizer {
2.         /**
3.          * 判断当前线程是否持有同步状态
4.          *
5.          * @return
6.          */
7.         @Override
8.         protected boolean isHeldExclusively() {
9.             return getExclusiveOwnerThread() == Thread.currentThread();
10.         }
11.     }

复制代码

在获取同步状态中

• 先判断是否有同步状态（即同步状态是否为0），如果有同步状态就用CAS去获取（0->1），成功就设置当前线程为获取同步状态的线程
  
• 如果没有同步状态（即同步状态不为0） ，就查看获取同步状态的线程是否为当前线程，如果是当前线程则说明此次是重入，累加重入次数
  
• 其他情况说明未获取到同步状态，返回false  后续走AQS流程（构建节点加入AQS）
  

1.                 /**
2.          * 尝试获取同步状态
3.          *
4.          * @param arg 获取同步状态的数量
5.          * @return
6.          */
7.         @Override
8.         protected boolean tryAcquire(int arg) {
9.             //1.获取同步状态
10.             int state = getState();
11.             //2.如果有同步状态则CAS替换 0->1
12.             if (state == 0) {
13.                 if (compareAndSetState(state, 1)) {
14.                     //替换成功 说明获取到同步状态 设置当前获取同步状态线程
15.                     setExclusiveOwnerThread(Thread.currentThread());
16.                     return true;
17.                 }
18.             } else if (getExclusiveOwnerThread() == Thread.currentThread()) {
19.                 //3.没有同步状态  查看获取同步资源的线程是否为当前线程  可重入  累加重入次数
20.                 setState(state + arg);
21.                 return true;
22.             }
24.             //其他情况就是没获取到同步状态
25.             return false;
26.         }

复制代码

在释放同步状态中
只有当同步状态要改成0时才是真正释放，否则情况情况下就是重入扣减次数

1.         /**
2.          * 尝试释放同步状态
3.          *
4.          * @param arg 释放同步状态的数量
5.          * @return
6.          */
7.         @Override
8.         protected boolean tryRelease(int arg) {
9.             //目标状态
10.             int targetState = getState() - arg;
12.             //真正释放锁
13.             if (targetState == 0) {
14.                 setExclusiveOwnerThread(null);
15.                 setState(targetState);
16.                 return true;
17.             }
19.             //其他情况 扣减状态
20.             setState(targetState);
21.             return false;
22.         }

复制代码

使用内部类实现AQS的方法后，我们在自定义同步组件类中去实现Lock接口，并用内部类实现AQS的方法去实现Lock接口的方法
将要获取、释放的同步状态都设置成1，对应响应中断、超时的方法就用AQS中对应的方法即可

1. public class MySynchronizedComponent implements Lock {
3.     public MySynchronizedComponent() {
4.         sync = new Sync();
5.     }
7.     private Sync sync;
9.     @Override
10.     public void lock() {
11.         sync.acquire(1);
12.     }
14.     @Override
15.     public void lockInterruptibly() throws InterruptedException {
16.         sync.acquireInterruptibly(1);
17.     }
19.     @Override
20.     public boolean tryLock() {
21.         return sync.tryAcquire(1);
22.     }
24.     @Override
25.     public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
26.         return sync.tryAcquireNanos(1, unit.toNanos(time));
27.     }
29.     @Override
30.     public void unlock() {
31.         sync.release(1);
32.     }
34.     @Override
35.     public Condition newCondition() {
36.         return sync.new ConditionObject();
37.     }
39. }

复制代码

实际上我们只需要去实现尝试获取、释放同步状态方法就能够完成自己的同步组件，这就是使用AQS带来的好处
代码案例可以去git仓库获取，放在本文最后
ReentrantLock

ReentrantLock是并发包中提供的可重入锁，它除了能够实现synchronized的功能外还可以响应中断、超时、实现公平锁等，其底层也是通过AQS来实现的
ReentrantLock的功能与synchronized类似，可重入的独占锁，用于保证并发场景下同步操作
使用时需要显示加锁、解锁，常用格式如下：

1. reentrantLock.lock();
2. try{
3.     //....
4. }finally {
5.     reentrantLock.unlock();
6. }

复制代码

finally中最先去解锁，并且加锁要放在try块的最外层，并保证加锁和try块之间不会抛出异常
加锁不放在try中是因为加锁实现未知可能抛出不受检查unchecked的异常，当加锁抛出异常时，后续finally块解锁也会抛出非法监视器的异常从而导致覆盖
加锁和try块之间如果抛出异常，那么就无法执行解锁了
ReentrantLock除了提供基本的同步功能，还提供响应中断、超时的API，同学们可以私下去查看
熟悉ReentrantLock实现的同学，可能看上面自定义同步组件的代码很熟悉，其实就是参考ReentrantLock非公平锁写的
ReentrantLock中使用内部类Sync来继承AQS，同时内部类NonfairSync和FairSync来继承Sync去实现非公平、公平的获取同步状态

非公平锁尝试获取同步状态 流程类似就不过多描述

1.                 final boolean nonfairTryAcquire(int acquires) {
2.             final Thread current = Thread.currentThread();
3.             int c = getState();
4.             if (c == 0) {
5.                 if (compareAndSetState(0, acquires)) {
6.                     setExclusiveOwnerThread(current);
7.                     return true;
8.                 }
9.             }
10.             else if (current == getExclusiveOwnerThread()) {
11.                 int nextc = c + acquires;
12.                 if (nextc < 0) // overflow
13.                     throw new Error("Maximum lock count exceeded");
14.                 setState(nextc);
15.                 return true;
16.             }
17.             return false;
18.         }

复制代码

那公平锁如何来实现获取同步状态呢？
其实看过上篇AQS文章的同学就知道了，在上篇文章中已经说过
只需要在尝试获取同步状态前加上一个条件：队列中是否有前置任务（即在队列中FIFO排队获取）
公平锁也是这么去实现的，前置条件hasQueuedPredecessors

1.                 protected final boolean tryAcquire(int acquires) {
2.             final Thread current = Thread.currentThread();
3.             int c = getState();
4.             if (c == 0) {
5.                 if (!hasQueuedPredecessors() &&
6.                     compareAndSetState(0, acquires)) {
7.                     setExclusiveOwnerThread(current);
8.                     return true;
9.                 }
10.             }
11.             else if (current == getExclusiveOwnerThread()) {
12.                 int nextc = c + acquires;
13.                 if (nextc < 0)
14.                     throw new Error("Maximum lock count exceeded");
15.                 setState(nextc);
16.                 return true;
17.             }
18.             return false;
19.         }

复制代码

ReentrantReadWriteLock

功能与实现

ReentrantReadWriteLock在ReentrantLock功能的基础上，提供读写锁的功能，让锁的粒度更细
在一些读多写少的场景下是允许同时读的，允许多个线程获取，其实想到了AQS的共享式，读锁也就是共享式
在读读的场景下，都是读锁/共享锁，不会进行阻塞
在读写、写读、写写的场景下，都会进行阻塞
比如要获取写锁时，需要等待读锁、写锁都解锁；要获取读锁时，需要等待写锁解锁
ReentrantReadWriteLock 在 ReentrantLock 的基础上增加ReadLock和WriteLock分别作为读锁和写锁

实际上读锁就是共享锁、写锁就是独占锁，在实现加锁、解锁的方法时分别调用共享式、独占式的获取、释放同步状态即可
在构造时，读写锁中实际使用的都是同一个AQS

1.         public ReentrantReadWriteLock(boolean fair) {
2.             sync = fair ? new FairSync() : new NonfairSync();
3.             readerLock = new ReadLock(this);
4.             writerLock = new WriteLock(this);
5.         }
7.                 //读锁构造
8.                 protected ReadLock(ReentrantReadWriteLock lock) {
9.             sync = lock.sync;
10.         }
12.                 //写锁构造
13.                 protected WriteLock(ReentrantReadWriteLock lock) {
14.             sync = lock.sync;
15.         }

复制代码

即同步状态会被读写锁共享，那么它们如何查看/修改自己的那部分同步状态呢？
在读写锁中，同步状态被一分为二，高16位的同步状态是读锁的，低16位的同步状态是写锁的

当线程获取写锁时，写状态+1，由于写状态在低位，相当于同步状态+1

<strong>当线程获取读锁时，读状态+1，由于读状态在高位，相当于同步状态+（1{                try {                    semaphore.acquire();                    System.out.println(Thread.currentThread().getName()+"获得资源");                    //执行任务                    TimeUnit.SECONDS.sleep(2);                } catch (InterruptedException e) {                    e.printStackTrace();                }finally {                    System.out.println(Thread.currentThread().getName()+"释放资源======");                    semaphore.release();                }            });        }        executor.shutdown();[/code]实现

熟悉AQS的同学应该可以猜到信号量其实就是通过共享式实现的
信号量构造时提供初始化信号量的数量，实际上就是初始化同步状态，比如设置2个信号量就是设置同步状态为2；还可以在构造中设置公平、非公平
在获取信号量时，使用响应中断的共享式，在非公平情况下执行nonfairTryAcquireShared

1. protected final boolean tryAcquire(int acquires) {
2.   
3.     Thread current = Thread.currentThread();
4.     //得到同步状态c
5.     int c = getState();
6.     //得到写状态（同步状态低16位 与上 全1）
7.     int w = exclusiveCount(c);
8.     if (c != 0) {
9.         //同步状态不为0,写状态为0,说明读状态不为0,读锁已经被获取,此时获取写锁失败
10.         //同步状态不为0,写状态也不为0,查看当前线程是否是获取写锁的线程,不是的话获取写锁失败
11.         if (w == 0 || current != getExclusiveOwnerThread())
12.             return false;
13.         
14.         //只有当前线程获取过写锁才能进入这里
15.         
16.         //如果原来的写状态+这次重入的写状态 超过了 同步状态的0~15位 则抛出异常
17.         if (w + exclusiveCount(acquires) > MAX_COUNT)
18.             throw new Error("Maximum lock count exceeded");
19.         
20.         //设置同步状态 因为写状态在低16位所以不用左移 (重入累加)
21.         setState(c + acquires);
22.         return true;
23.     }
24.    
25.     //同步状态为0 无锁时
26.     //writerShouldBlock在非公平锁下返回false 在公平锁下查看是否有前驱任务
27.     //如果CAS失败则返回false
28.     if (writerShouldBlock() ||
29.         !compareAndSetState(c, c + acquires))
30.         return false;
31.    
32.     //CAS成功则 设置当前线程为获得独占锁(写锁)的线程
33.     setExclusiveOwnerThread(current);
34.     return true;
35. }

复制代码

在获取时实际上就是扣减要获取的信号量，可能多个线程同时获取信号量，使用CAS+失败重试保证原子性，直到没有信号量或CAS成功
在释放信号量时实际就是加上释放的信号量，可能多个线程同时释放信号量，因此释放时使用CAS+失败重试保证原子性

1. protected final boolean tryRelease(int releases) {
2.     //判断当前线程是不是获取写(独占)锁的线程
3.     if (!isHeldExclusively())
4.         throw new IllegalMonitorStateException();
5.    
6.     //新状态
7.     int nextc = getState() - releases;
8.     //如果新状态低16位为0(没有写锁)就设置获取写锁的线程为空,然后设置同步状态,再返回
9.     boolean free = exclusiveCount(nextc) == 0;
10.     if (free)
11.         setExclusiveOwnerThread(null);
12.    
13.     setState(nextc);
14.     return free;
15. }

复制代码

CountDownLatch

CountDownLatch 相当于一个计数器，在构造时设置计数数量
功能

调用countDown方法会对数量进行自减
调用await方法时，如果还有数量没被扣减完，则会阻塞，直到数量都被扣减完
当一个线程执行N个任务，或者多个线程执行一个任务时，要等待它们执行完再进行下一步操作时，就可以使用CountDownLatch

1.                 protected final int tryAcquireShared(int unused) {
2.             
3.             Thread current = Thread.currentThread();
4.             //同步状态
5.             int c = getState();
6.             
7.             //exclusiveCount 为获取写锁状态 低16位全与1
8.             //如果有写锁 并且 获取写锁的线程不是当前线程 则失败(说明允许同一线程获取写锁再获取读锁)
9.             if (exclusiveCount(c) != 0 &&
10.                 getExclusiveOwnerThread() != current)
11.                 return -1;
12.             
13.             //获取读状态  (同步状态右移16位)
14.             int r = sharedCount(c);
15.             //读没被阻塞 没超过最大值 且CAS成功 记录信息 返回成功
16.             if (!readerShouldBlock() &&
17.                 r < MAX_COUNT &&
18.                 compareAndSetState(c, c + SHARED_UNIT)) {
19.                 if (r == 0) {
20.                     firstReader = current;
21.                     firstReaderHoldCount = 1;
22.                 } else if (firstReader == current) {
23.                     firstReaderHoldCount++;
24.                 } else {
25.                     HoldCounter rh = cachedHoldCounter;
26.                     if (rh == null || rh.tid != getThreadId(current))
27.                         cachedHoldCounter = rh = readHolds.get();
28.                     else if (rh.count == 0)
29.                         readHolds.set(rh);
30.                     rh.count++;
31.                 }
32.                 return 1;
33.             }
34.             return fullTryAcquireShared(current);
35.         }

复制代码

实现

其实它的实现与信号量类似，也是通过共享式
在构造中设置初始值时，实际上就是在设置同步状态
当执行countDown扣减数量时，实际上就是在扣减同步状态 ，由于可能多线程同时执行，使用CAS+失败重试保证扣减同步状态成功

1.                 //初始化信号量
2.         Semaphore semaphore = new Semaphore(2);
3.         
4.         //每次只有两个线程能够获取到信号量执行
5.         ExecutorService executor =  Executors.newFixedThreadPool(4);
6.         for (int i = 0; i < 10; i++) {
7.             executor.execute(()->{
8.                 try {
9.                     semaphore.acquire();
10.                     System.out.println(Thread.currentThread().getName()+"获得资源");
12.                     //执行任务
13.                     TimeUnit.SECONDS.sleep(2);
14.                 } catch (InterruptedException e) {
15.                     e.printStackTrace();
16.                 }finally {
17.                     System.out.println(Thread.currentThread().getName()+"释放资源======");
18.                     semaphore.release();
19.                 }
20.             });
21.         }
23.         executor.shutdown();

复制代码

执行await时，实际就是判断同步状态是否为0，不是则说明有的线程还未执行完任务，阻塞等待

1.                 final int nonfairTryAcquireShared(int acquires) {
2.             for (;;) {
3.                 //获取同步状态
4.                 int available = getState();
5.                 //目标同步状态
6.                 int remaining = available - acquires;
7.                 //没有信号量 或 CAS成功 都会返回目标同步状态 为负数时获取失败
8.                 if (remaining < 0 ||
9.                     compareAndSetState(available, remaining))
10.                     return remaining;
11.             }
12.         }

复制代码

CyclicBarrier

cyclic Barrier 是一个可循环使用的屏障，它常常被用来和countdownlatch作比较
它就像一个屏障，让线程执行完任务后遇到屏障阻塞，直到所有线程都执行完任务（都到达屏障），并且它是可重复使用的

1.                 protected final boolean tryReleaseShared(int releases) {
2.             for (;;) {
3.                 int current = getState();
4.                 int next = current + releases;
5.                 if (next < current) // overflow
6.                     throw new Error("Maximum permit count exceeded");
7.                 if (compareAndSetState(current, next))
8.                     return true;
9.             }
10.         }

复制代码

task方法中会执行await阻塞直到所有线程到达屏障

1. //初始化10
2. CountDownLatch countDownLatch = new CountDownLatch(10);
3. //固定线程池
4. ExecutorService executor = Executors.newFixedThreadPool(10);
5. for (int i = 1; i <= 10; i++) {
6.     final int index = i;
7.     executor.execute(() -> {
8.         System.out.println(Thread.currentThread() + "处理任务" + index);
9.         
10.         //执行任务...
11.         
12.         //数量-1
13.         countDownLatch.countDown();
14.     });
15. }
18. //计数量为0时才可以继续执行
19. countDownLatch.await();
20. System.out.println("处理完任务");
22. executor.shutdown();

复制代码

cyclic barrier会记录需要多少线程到达屏障，并且通过代来达到重复使用
使用reentrant lock 在await中加锁、解锁，每当一个线程到达屏障（执行await时），都会进行自减，如果不为0会阻塞，自减到0时说明所有线程到达屏障，唤醒其他线程，并更新新的代
Exchange

Exchanger用于线程间的协作，可以用来交换变量

1. protected boolean tryReleaseShared(int releases) {
2.     // Decrement count; signal when transition to zero
3.     for (;;) {
4.         int c = getState();
5.         if (c == 0)
6.             return false;
7.         int nextc = c-1;
8.         if (compareAndSetState(c, nextc))
9.             return nextc == 0;
10.     }
11. }

复制代码

当一个线程先执行exchange时会等待另一个线程执行，等到另一个线程exchange时则唤醒等待的线程
总结

本篇文章围绕前置知识AQS原理，来实现自定义的同步组件，并对并发包中常用同步组件的功能和原理进行说明
继承AQS后，只需要实现尝试获取、释放同步状态等方法就可以自定义同步组件
ReentrantLock 是由AQS实现的独占式可重入锁，初始值同步状态为0；获取锁时，如果是无锁则尝试CAS自增，成功就获取了锁；如果有锁则判断获取锁的线程是不是当前线程，是则说明是可重入锁自增次数；在释放锁时由于可重入的关系，只有自减为0才是真正释放锁
ReentrantLock 还提供响应中断、超时、公平锁的其他功能，公平锁实现只需要加上获取锁的前提：在AQS中FIFO排队，前驱节点为首节点
ReentrantReadWriteLock 提供共享的读锁和独占的写锁，将锁的状况更加细粒度，将同步状态高低16位拆分为读、写的状态，在读多写少的场景并发性能会更好；在获取写锁时，如果有读锁那么会阻塞，如果有写锁会查看是否为可重入；在获取读锁时，没有写锁就可以获取，如果写锁是当前线程也可以获取
信号量用于控制线程访问资源，初始化自定义的信号量数量，线程访问资源时先获取信号量，获取到信号量才能够访问资源；使用共享式来实现，由于可能多个线程同时获取、释放信号量，在实现时都需要使用CAS+失败重试保证原子性
CountDownLatch 用于计数，可以用于一个线程执行N个任务，也可以用于多个线程执行1个任务，当执行完任务使用countdown 来对同步状态进行扣减，执行await方法时只要同步状态不为0就会阻塞线程，直到所有任务执行完（将同步状态扣减完）
CyclicBarrier 是可循环使用的屏障，用于多线程到达屏障后，需要等待其他线程都到达屏障才继续执行；使用reentrant lock 和 代 来实现，调用await时自减，当计数为0时说明所有线程到达屏障，唤醒其他阻塞的线程
Exchange 用于线程间的协作，能够交换线程间的变量
最后（不要白嫖，一键三连求求拉~）

本篇文章被收入专栏 由点到线，由线到面，深入浅出构建Java并发编程知识体系，感兴趣的同学可以持续关注喔
本篇文章笔记以及案例被收入 gitee-StudyJava、 github-StudyJava 感兴趣的同学可以stat下持续关注喔~
案例地址：
Gitee-JavaConcurrentProgramming/src/main/java/C_AQSComponent
Github-JavaConcurrentProgramming/src/main/java/C_AQSComponent
有什么问题可以在评论区交流，如果觉得菜菜写的不错，可以点赞、关注、收藏支持一下~
关注菜菜，分享更多干货，公众号：菜菜的后端私房菜

本文由博客一文多发平台 OpenWrite 发布！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！