自定义AQS同步器：互斥锁

自定义互斥锁：

参考jdk的ReentrantLock可重入锁源码，定义一个互斥锁。

因为锁是独占方式，所以重写AQS的tryAcquire()、tryRelease()、isHeldExclusively()方法即可！

import org.jetbrains.annotations.NotNull;

import java.io.Serializable;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * @description: 自定义互斥锁 共享资源（state）锁状态这里只有两种状态：0-未被锁定 1-锁定
 * @author: yangzihe(ys1405)
 * @create: 2020-03-21 11:05
 **/
public class MyMutexLock implements Lock, Serializable {
    //自定义同步器
    private static final class Sync extends AbstractQueuedSynchronizer {
        //判断当前线程是否正在独占资源，即锁资源是否处于锁定状态
        @Override
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }

        //获取锁
        @Override
        protected boolean tryAcquire(int arg) {
            assert arg == 1;//只可为1
            if (compareAndSetState(0, 1)) {//state为0时设置为1（CAS修改），无重入
                setExclusiveOwnerThread(Thread.currentThread());//设置当前线程独占共享资源state
                return true;
            }
            return false;
        }

        //释放锁
        @Override
        protected boolean tryRelease(int arg) {
            assert arg == 1;//限定为1
            if (getState() == 0) {//当前线程得到的state=0，即未占有锁
                throw new IllegalMonitorStateException();
            }
            setExclusiveOwnerThread(null);
            setState(0);//释放锁
            return true;
        }

        final ConditionObject newCondition() {
            return new ConditionObject();
        }
    }

    //同步类的实现都是依赖自定义的同步器。模板模式：调用AQS方法，底层调用的是重写的方法
    private final Sync sync = new Sync();

    //获取锁对象，自旋等待，一直等到获取成功才返回
    @Override
    public void lock() {
        sync.acquire(1);//1：tryAcquire()的入参
    }

    //获取锁对象，可中断
    @Override
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

    //尝试获取锁
    @Override
    public boolean tryLock() {
        return sync.tryAcquire(1);
    }

    //尝试获取锁，过了time时间后放弃
    @Override
    public boolean tryLock(long time, @NotNull TimeUnit unit) throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(time));
    }

    //释放锁
    @Override
    public void unlock() {
        sync.release(1);
    }

    @NotNull
    @Override
    public Condition newCondition() {
        return sync.newCondition();
    }
}

jdk的CountDownLatch源码笔记记录：

public class CountDownLatch {
    /**
     * 继承AQS的内部Sync同步器
     */
    private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;

        //使用AQS的state来表示计数count.
        Sync(int count) {
            // 使用AQS的setState()方法设置状态
            setState(count);
        }


        int getCount() {
            // 使用AQS的getState()方法获取状态
            return getState();
        }


        // 重写在共享模式下获取锁，count=0表所有需等待的线程执行完毕，获取锁成功，代码可以继续往下执行
        protected int tryAcquireShared(int acquires) {
            // 这里用状态state是否为0来表示是否成功，为0的时候可以获取到返回1，否则不可以返回-1
            return (getState() == 0) ? 1 : -1;
        }


        // 重写在共享模式下释放锁
        protected boolean tryReleaseShared(int releases) {
            // 在for循环中Decrement count直至成功;
            // 当状态值即count为0的时候，返回false表示 signal when transition to zero
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                //cas操作
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }
    }


    private final Sync sync;


    // 使用给定计数值构造CountDownLatch
    public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }


    // 让当前线程阻塞直到计数count变为0，或者线程被中断
    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }


    // 阻塞当前线程，除非count变为0或者等待了timeout的时间。当count变为0时，返回true
    public boolean await(long timeout, TimeUnit unit)
        throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }


    // count递减
    public void countDown() {
        sync.releaseShared(1);
    }


    // 获取当前count值
    public long getCount() {
        return sync.getCount();
    }


    public String toString() {
        return super.toString() + "[Count = " + sync.getCount() + "]";
    }
}