Condition、CountDownLatch、Semaphore源码分析

基本概念

Condition是一个接口，提供了两个核心方法，await()和signal方法，分别对应着object的wait和notify方法，调用Object对象的这两个方法，需要在同步代码块里面，必须获取到锁才能执行这两个方法，同理，Condition调用这两个方法，也必须先获取到锁

1. 等待队列：用于存放lock锁中调用await方法，当前线程会变为阻塞状态，同时会释放锁，单向链表存放
2. 同步队列:用于存放没有竞争到锁，采用双向链表存放

使用

package com.mayikt;

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

/**
 * @Description:
 * @Author: ChenYi
 * @Date: 2020/07/26 16:33
 **/

public class Test005 {
    private static Lock lock = new ReentrantLock();
    private static Condition condition = lock.newCondition();

    public static void main(String[] args) {
        new Thread(() -> {
            System.out.println("1");
            try {
                lock.lock();
                //等待
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("2");
            lock.unlock();
        }, "t1").start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("3");
        lock.lock();
        //唤醒
        condition.signal();
        lock.unlock();
    }
}

Condition源码解读

public final void await() throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
// 将当前节点添加到最后一个节点
    Node node = addConditionWaiter();
//释放锁的状态
    long savedState = fullyRelease(node);
    int interruptMode = 0;
    while (!isOnSyncQueue(node)) {
// 如果当前线程为-2 则当前线程变为阻塞状态
        LockSupport.park(this);
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;
    }
//重新获取锁
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        interruptMode = REINTERRUPT;
    if (node.nextWaiter != null) // clean up if cancelled
        unlinkCancelledWaiters();
    if (interruptMode != 0)
        reportInterruptAfterWait(interruptMode);
}

public final void signal() {
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
     //获取单向链表，
    Node first = firstWaiter;
    if (first != null)
        doSignal(first);
}

CountDownLatch源码分析

CountDownLatch是一种java.util.concurrent包下一个同步工具类，能够允许一个或者多个线程等待直到其他线程一组操作执行完成，基于CountDownLatch底层是基于AQS实现的

简单案例

   public static void main(String[] args) throws InterruptedException {
        CountDownLatch downLatch = new CountDownLatch(2);
        new Thread(() -> {
            System.out.println("1");
            try {
                downLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("2");
        }).start();
        Thread.sleep(3000);
        System.out.println("3");
        downLatch.countDown();
        downLatch.countDown();
    }

CountDownLatch countDownLatch=new CountDownLatch(2) AQS的state状态为2
调用countDownLatch.countDown();方法的时候状态减1 当AQS状态state为0的情况下，则唤醒正在等待的线程。

基于AQS手写CountDownLatch

核心是需要重写tryAcquireShared阻塞线程的判断和tryReleaseShared释放线程的判断的方法

public final void acquireSharedInterruptibly(int arg)
        throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
// 如果tryAcquireShared返回小于0的情况下，可以让当前
线程变为阻塞状态。
    if (tryAcquireShared(arg) < 0)
    //把当前线程变为阻塞状态
        doAcquireSharedInterruptibly(arg);
    }
}

/**
 * 如果状态小于=0的情况下 则不需要阻塞线程，如果>0的情况下，则需要阻塞当前线程
 *
 * @param arg
 * @return
 */
@Override
protected int tryAcquireShared(int arg) {
    return getState() == 0 ? 1 : -1;
}

public final boolean releaseShared(int arg) {
// 如果状态为0的情况下，则调用doReleaseShared唤醒正在等待的线程
    if (tryReleaseShared(arg)) {
    //唤醒线程
        doReleaseShared();
        return true;
    }
    return false;
}


protected boolean tryReleaseShared(int arg) {
    for (; ; ) {
        int state = getState();
        //如果 state 已经小于等于0了，说明等待线程已经被唤醒了。就不用这个线程来再次唤醒了
        if (state <= 0) return false;
        int nextS = state - arg;
        if (compareAndSetState(state, nextS)) {
            return nextS == 0;//这时如果小于等于0，就应该去唤醒等待线程了
        }
    }
}

CountDownLatch与Join的区别

Join底层是基于wait方法实现，而CountDownLatch底层是基于AQS实现。

Semaphore

Semaphore用于限制可以访问某些资源的线程数目，维护了一个许可证，有多少资源需要限制就维护多少许可证集合，假如有N个资源，那就需要对应N个许可证，同一时刻也就只能有N个线程访问，一个线程获取许可证就调用acuqire方法，用完了释放资源就调用release方法，Semaphore信号量可以实现对接口限流，底层是基于aqs实现

Semaphore工作原理

1. 可以设置Semaphore信号量的 状态state值为5
2. 当一个线程获取到锁的情况下，将state-1，锁释放成功之后state+1；
3. 当state<0，表示没锁的资源，则当前线程阻塞。

简单使用

public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(5);
        IntStream.rangeClosed(1, 10).forEach(i -> {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + ",线程进入");
                //aqs加1
                semaphore.release();
            }).start();
        });
    }

基于AQS手写Semaphore

核心是需要重写tryAcquireShared阻塞线程的判断和tryReleaseShared释放线程的判断的方法

    @Override
        protected int tryAcquireShared(int arg) {
            for (; ; ) {
                int oldState = getState();
                int newState = oldState - arg;
                if (compareAndSetState(oldState, newState)) {
                    return newState < 0 ? -1 : 1;
                }
            }
        }

        @Override
        protected boolean tryReleaseShared(int arg) {
            for (; ; ) {
                int oldState = getState();
                int newState = oldState + arg;
                if (newState < 0) {
                    throw new RuntimeException("不合法");
                }
                if (compareAndSetState(oldState, newState)) {
                    return true;
                }
            }
        }

参考：蚂蚁课堂