Java多线程再学习，温故知新（五）AbstractQueuedSynchronizer(AQS)

╰+哭是因爲堅強的太久メ 2022-03-25 03:28 211阅读 0赞

[JDK在线文档][JDK]

AbstractQueuedSynchronizer为实现依赖于先进先出 (FIFO) 等待队列的阻塞锁和相关同步器（信号量、事件，等等）提供一个框架。

此类的设计目标是成为依靠单个原子 int 值来表示状态的大多数同步器的一个有用基础。子类必须定义更改此状态的受保护方法，并定义哪种状态对于此对象意味着被获取或被释放。假定这些条件之后，此类中的其他方法就可以实现所有排队和阻塞机制。子类可以维护其他状态字段，但只是为了获得同步而只追踪使用 getState()、setState(int) 和 compareAndSetState(int, int) 方法来操作以原子方式更新的 int 值。

应该将子类定义为非公共内部帮助器类，可用它们来实现其封闭类的同步属性。类 AbstractQueuedSynchronizer 没有实现任何同步接口。而是定义了诸如 acquireInterruptibly(int) 之类的一些方法，在适当的时候可以通过具体的锁和相关同步器来调用它们，以实现其公共方法。

此类支持默认的独占 模式和共享 模式之一，或者二者都支持。处于独占模式下时，其他线程试图获取该锁将无法取得成功。在共享模式下，多个线程获取某个锁可能（但不是一定）会获得成功。此类并不“了解”这些不同，除了机械地意识到当在共享模式下成功获取某一锁时，下一个等待线程（如果存在）也必须确定自己是否可以成功获取该锁。处于不同模式下的等待线程可以共享相同的 FIFO 队列。通常，实现子类只支持其中一种模式，但两种模式都可以在（例如）ReadWriteLock 中发挥作用。只支持独占模式或者只支持共享模式的子类不必定义支持未使用模式的方法。

此类通过支持独占模式的子类定义了一个嵌套的 AbstractQueuedSynchronizer.ConditionObject 类，可以将这个类用作 Condition 实现。isHeldExclusively() 方法将报告同步对于当前线程是否是独占的；使用当前 getState() 值调用 release(int) 方法则可以完全释放此对象；如果给定保存的状态值，那么 acquire(int) 方法可以将此对象最终恢复为它以前获取的状态。没有别的 AbstractQueuedSynchronizer 方法创建这样的条件，因此，如果无法满足此约束，则不要使用它。AbstractQueuedSynchronizer.ConditionObject 的行为当然取决于其同步器实现的语义。

此类为内部队列提供了检查、检测和监视方法，还为 condition 对象提供了类似方法。可以根据需要使用用于其同步机制的 AbstractQueuedSynchronizer 将这些方法导出到类中。

此类的序列化只存储维护状态的基础原子整数，因此已序列化的对象拥有空的线程队列。需要可序列化的典型子类将定义一个 readObject 方法，该方法在反序列化时将此对象恢复到某个已知初始状态。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2llZmxleA_size_16_color_FFFFFF_t_70][]

## 自定义同步器实现时主要实现以下几种方法： ##

为了将此类用作同步器的基础，需要适当地重新定义以下方法，这是通过使用 getState()、setState(int) 和/或 compareAndSetState(int, int) 方法来检查和/或修改同步状态来实现的：

isHeldExclusively()：该线程是否是独占方式。只有用到condition才需要去实现它。  
tryAcquire(int)：独占方式。尝试获取资源，成功则返回true，失败则返回false。  
tryRelease(int)：独占方式。尝试释放资源，成功则返回true，失败则返回false。  
tryAcquireShared(int)：共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。  
tryReleaseShared(int)：共享方式。尝试释放资源，如果释放后允许唤醒后续等待结点返回true，否则返回false。  
　　默认情况下，每个方法都抛出 UnsupportedOperationException。这些方法的实现在内部必须是线程安全的，通常应该很短并且不被阻塞。定义这些方法是使用此类的 唯一 受支持的方式。其他所有方法都被声明为 final，因为它们无法是各不相同的。

## 源码详解 ##

首先关注java.util.concurrent.locks.ReentrantLock

## lock()  ##

加锁方法通过同步器的lock方法来加锁，同步器是一个内部类实现了AbstractQueuedSynchronizer，加锁方法主要是通过调用acquired()来实现的。

public void lock() {
         sync.lock();
    }
    
    abstract static class Sync extends AbstractQueuedSynchronizer {
        //...
    }
    //非公平锁
    static final class NonfairSync extends Sync {
            final void lock() {
                if (compareAndSetState(0, 1))
                    setExclusiveOwnerThread(Thread.currentThread());
                else
                    acquire(1);
            }
    }
    //公平锁
    static final class FairSync extends Sync {
            final void lock() {
                acquire(1);
            }
    }

公平是针对锁的获取而言的，如果一个锁是公平的，那么锁的获取顺序就应该符合请求的绝对时间顺序。

## acquire(int) ##

此方法是独占模式下线程获取共享资源的顶层入口。如果获取到资源，线程直接返回，否则进入等待队列，直到获取到资源为止，且整个过程忽略中断的影响。这也正是lock()的语义，当然不仅仅只限于lock()。获取到资源后，线程就可以去执行其临界区代码了。下面是acquire()的源码：

public final void acquire(int arg) {
         if (!tryAcquire(arg) &&//第一个线程进入或者锁重入都可以拿到锁，拿不到锁继续往下执行
             acquireQueued(addWaiter(Node.EXCLUSIVE), arg))//如果拿不到锁需要加入等待队列中
             selfInterrupt();
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2llZmxleA_size_16_color_FFFFFF_t_70 1][]

1.调用自定义同步器的tryAcquire()尝试直接去获取资源，如果成功则直接返回；  
2.没成功，则addWaiter()将该线程加入等待队列的尾部，并标记为独占模式；  
3.acquireQueued()使线程在等待队列中休息，有机会时（轮到自己，会被unpark()）会去尝试获取资源。获取到资源后才返回。如果在整个等待过程中被中断过，则返回true，否则返回false。  
4.如果线程在等待过程中被中断过，它是不响应的。只是获取资源后才再进行自我中断selfInterrupt()，将中断补上。

### tryAcquire(int) ###

此方法尝试去获取独占资源。如果获取成功，则直接返回true，否则直接返回false。如下是tryAcquire()的源码：

protected boolean tryAcquire(int arg) {
            throw new UnsupportedOperationException();
        }

这段是AbstractQueuedSynchronizer里的源码，一般这方法会被子类重写掉，完成子类里我们需要的功能，我们来关注下子类ReentrantLock->FairSync 里的实现方法。

protected final boolean tryAcquire(int acquires) {
                final Thread current = Thread.currentThread();
                int c = getState();//获取同步状态，状态值用子类Node来定义
                if (c == 0) {//如果同步状态是初始化状态
                    if (!hasQueuedPredecessors() &&//如果之前没有节点了能获取锁才继续执行
                        compareAndSetState(0, acquires)) {//设置当前线程的同步状态
                        setExclusiveOwnerThread(current);//把当前线程设置为独占线程，持有锁
                        return true;
                    }
                }
                else if (current == getExclusiveOwnerThread()) {//持有锁的如果是当前线程，锁重入的情况
                    int nextc = c + acquires;//相当于记录重入的次数
                    if (nextc < 0)//状态如果还小于0，抛出异常
                        throw new Error("Maximum lock count exceeded");
                    setState(nextc);//设置重入次数
                    return true;
                }
                return false;
            }

## Node值定义 ##

Node是对每一个访问同步代码的线程的封装，其包含了需要同步的线程本身以及线程的状态，如是否被阻塞，是否等待唤醒，是否已经被取消等。变量waitStatus则表示当前被封装成Node结点的等待状态，共有4种取值CANCELLED、SIGNAL、CONDITION、PROPAGATE。

CANCELLED：值为1，在同步队列中等待的线程等待超时或被中断，需要从同步队列中取消该Node的结点，其结点的waitStatus为CANCELLED，即结束状态，进入该状态后的结点将不会再变化。

SIGNAL：值为-1，被标识为该等待唤醒状态的后继结点，当其前继结点的线程释放了同步锁或被取消，将会通知该后继结点的线程执行。说白了，就是处于唤醒状态，只要前继结点释放锁，就会通知标识为SIGNAL状态的后继结点的线程执行。

CONDITION：值为-2，与Condition相关，该标识的结点处于等待队列中，结点的线程等待在Condition上，当其他线程调用了Condition的signal()方法后，CONDITION状态的结点将从等待队列转移到同步队列中，等待获取同步锁。

PROPAGATE：值为-3，与共享模式相关，在共享模式中，该状态标识结点的线程处于可运行状态。

0状态：值为0，代表初始化状态。

AQS在判断状态时，通过用waitStatus>0表示取消状态，而waitStatus<0表示有效状态。

###  addWaiter(Node) ###

此方法用于将当前线程加入到等待队列的队尾，并返回当前线程所在的结点。

private Node addWaiter(Node mode) {
        //以给定模式构造结点。mode有两种：EXCLUSIVE（独占）和SHARED（共享）
        Node node = new Node(Thread.currentThread(), mode);
        
        //尝试快速方式直接放到队尾。以下是双向链表操作
        Node pred = tail;
        if (pred != null) {//如果尾节点不为空
            node.prev = pred;//把当前节点node的前一个prev变成（指向）尾节点
            if (compareAndSetTail(pred, node)) {//把当前节点变成尾节点
                pred.next = node;//把尾节点pred的下一个next 变成（指向）当前节点
                return node;//返回当前节点
            }
        }
        
        //上一步失败则通过enq入队，尾节点为空情况。
        enq(node);
        return node;
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2llZmxleA_size_16_color_FFFFFF_t_70 2][]

###  enq(Node) ###

此方法用于将node加入队尾。

private Node enq(final Node node) {
        //CAS"自旋"，直到成功加入队尾
        for (;;) {
            Node t = tail;
            if (t == null) { // 队列为空，创建一个空的标志结点作为head结点，并将tail也指向它。
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {//正常流程，放入队尾
                node.prev = t;//如果尾节点不为空，则把新创建的节点node的前一个prev指向尾节点
                if (compareAndSetTail(t, node)) {//把当前节点更新为尾节点
                    t.next = node;//把尾节点t的下一个next更新（指向为）当前节点
                    return t;
                }
            }
        }
    }

### acquireQueued(Node, int) ###

通过tryAcquire()和addWaiter()，该线程获取资源失败，已经被放入等待队列尾部了。下一步进入等待状态休息，直到其他线程彻底释放资源后唤醒自己，自己再拿到资源，然后就可以去干自己想干的事了。acquireQueued()就是干这件事：在等待队列中排队拿号（中间没其它事干可以休息），直到拿到号后再返回。

final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;//标记是否成功拿到资源
        try {
            boolean interrupted = false;//标记等待过程中是否被中断过
            
            //又是一个“自旋”！
            for (;;) {
                final Node p = node.predecessor();//拿到node的前一个节点
                //如果前一个节点是head，即该结点已成老二，那么便有资格去尝试获取资源（可能是老大释放完资源唤醒自己的，当然也可能被interrupt了）。
                if (p == head && tryAcquire(arg)) {
                    setHead(node);//拿到资源后，将head指向该结点。所以head所指的标杆结点，就是当前获取到资源的那个结点或null。
                    p.next = null; // setHead中node.prev已置为null，此处再将head.next置为null，就是为了方便GC回收以前的head结点。也就意味着之前拿完资源的结点出队了！
                    failed = false;
                    return interrupted;//返回等待过程中是否被中断过
                }
                
                //如果自己可以休息了，就进入waiting状态，直到被unpark()
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;//如果等待过程中被中断过，哪怕只有那么一次，就将interrupted标记为true
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

到这里了，我们先不急着总结acquireQueued()的函数流程，先看看shouldParkAfterFailedAcquire()和parkAndCheckInterrupt()具体干些什么。

###  shouldParkAfterFailedAcquire(Node, Node) ###

此方法主要用于检查状态，canceled状态需要移除，把可以设置为signal(等待唤醒状态)的设置为signal，有等待唤醒的才返回。

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;//拿到前一个节点的状态
        if (ws == Node.SIGNAL)
            //如果已经告诉前驱拿完号后通知自己一下，那就可以安心休息了
            return true;
        if (ws > 0) {//有canceled状态需要移除
            /*
             * 如果前一个节点是canceled，那就一直往前找，直到找到最近一个正常等待的状态，并排在它的后边。
             * 注意：那些canceled结点，由于被自己“加塞”到它们前边，它们相当于形成一个无引用链，稍后就会被GC回收
             */
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
             //把前一个节点的状态设置成SIGNAL，告诉它拿完号后通知自己一下
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

### parkAndCheckInterrupt() ###

如果线程找好安全休息点后，那就可以安心去休息了。此方法就是让线程去休息，真正进入等待状态。

private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);//调用park()使线程进入waiting状态
        return Thread.interrupted();//如果被唤醒，查看自己是不是被中断的。
    }

park()会让当前线程进入waiting状态。在此状态下，有两种途径可以唤醒该线程：1）被unpark()；2）被interrupt()。

看了shouldParkAfterFailedAcquire()和parkAndCheckInterrupt()，现在让我们再回到acquireQueued()，总结下该函数的具体流程：

1.结点进入队尾后，检查状态，找到安全休息点；  
2.调用park()进入waiting状态，等待unpark()或interrupt()唤醒自己；  
3.被唤醒后，看自己是不是有资格能拿到号。如果拿到，head指向当前结点，并返回从入队到拿到号的整个过程中是否被中断过；如果没拿到，继续流程1。

## unlock()  ##

解锁方法通过同步器的release方法来解锁。

public void unlock() {
            sync.release(1);
        }

### release(int) ###

此方法是独占模式下线程释放共享资源的顶层入口。它会释放指定量的资源，如果彻底释放了（即state=0）,它会唤醒等待队列里的其他线程来获取资源。这也正是unlock()的语义，当然不仅仅只限于unlock()。它是根据tryRelease()的返回值来判断该线程是否已经完成释放掉资源了！所以自定义同步器在设计tryRelease()的时候要明确这一点。下面是release()的源码：

public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;//找到头结点
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);//唤醒等待队列里的下一个线程
            return true;
        }
        return false;
    }

### tryRelease(int) ###

此方法尝试去释放指定量的资源。下面是tryRelease()的源码：

protected boolean tryRelease(int arg) {
        throw new UnsupportedOperationException();
    }

ReenTrantLock类的tryRelease实现方法

protected final boolean tryRelease(int releases) {
                int c = getState() - releases;
                if (Thread.currentThread() != getExclusiveOwnerThread())//如果锁不是当前线程的独占抛出异常
                    throw new IllegalMonitorStateException();
                boolean free = false;
                if (c == 0) {//线程的所有锁都释放时，设置释放状态为真，设置锁的独占线程为空
                    free = true;
                    setExclusiveOwnerThread(null);
                }
                setState(c);
                return free;
            }

## unparkSuccessor(Node) ##

此方法用于唤醒等待队列中下一个线程。下面是源码：

private void unparkSuccessor(Node node) {
        //这里，node一般为当前线程所在的结点。
        int ws = node.waitStatus;
        if (ws < 0)//置零当前线程所在的结点状态，允许失败。
            compareAndSetWaitStatus(node, ws, 0);
    
        Node s = node.next;//找到下一个需要唤醒的结点s
        if (s == null || s.waitStatus > 0) {//如果为空或已取消
            s = null;
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)//从这里可以看出，<=0的结点，都是还有效的结点。
                    s = t;
        }
        if (s != null)
            LockSupport.unpark(s.thread);//唤醒
    }

用unpark()唤醒等待队列中最前边的那个未放弃线程，这里我们也用s来表示吧。此时，再和acquireQueued()联系起来，s被唤醒后，进入if (p == head && tryAcquire(arg))的判断（即使p!=head也没关系，它会再进入shouldParkAfterFailedAcquire()寻找一个安全点。这里既然s已经是等待队列中最前边的那个未放弃线程了，那么通过shouldParkAfterFailedAcquire()的调整，s也必然会跑到head的next结点，下一次自旋p==head就成立啦），然后s把自己设置成head标杆结点，表示自己已经获取到资源了，acquire()也返回

\----------------------------------------------------------------------------------------------------------------

### acquireShared(int) ###

此方法是共享模式下线程获取共享资源的顶层入口。它会获取指定量的资源，获取成功则直接返回，获取失败则进入等待队列，直到获取到资源为止，整个过程忽略中断。下面是acquireShared()的源码：

public final void acquireShared(int arg) {
        if (tryAcquireShared(arg) < 0)
            doAcquireShared(arg);
    }

这里tryAcquireShared()依然需要自定义同步器去实现。但是AQS已经把其返回值的语义定义好了：负值代表获取失败；0代表获取成功，但没有剩余资源；正数表示获取成功，还有剩余资源，其他线程还可以去获取。所以这里acquireShared()的流程就是：

tryAcquireShared()尝试获取资源，成功则直接返回；  
失败则通过doAcquireShared()进入等待队列，直到获取到资源为止才返回。

### doAcquireShared(int) ###

此方法用于将当前线程加入等待队列尾部休息，直到其他线程释放资源唤醒自己，自己成功拿到相应量的资源后才返回。下面是doAcquireShared()的源码：

private void doAcquireShared(int arg) {
        final Node node = addWaiter(Node.SHARED);//加入队列尾部
        boolean failed = true;//是否成功标志
        try {
            boolean interrupted = false;//等待过程中是否被中断过的标志
            for (;;) {
                final Node p = node.predecessor();//前驱
                if (p == head) {//如果到head的下一个，因为head是拿到资源的线程，此时node被唤醒，很可能是head用完资源来唤醒自己的
                    int r = tryAcquireShared(arg);//尝试获取资源
                    if (r >= 0) {//成功
                        setHeadAndPropagate(node, r);//将head指向自己，还有剩余资源可以再唤醒之后的线程
                        p.next = null; // help GC
                        if (interrupted)//如果等待过程中被打断过，此时将中断补上。
                            selfInterrupt();
                        failed = false;
                        return;
                    }
                }
                
                //判断状态，寻找安全点，进入waiting状态，等着被unpark()或interrupt()
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

跟acquireQueued()很相似？对，其实流程并没有太大区别。只不过这里将补中断的selfInterrupt()放到doAcquireShared()里了，而独占模式是放到acquireQueued()之外，其实都一样，不知道Doug Lea是怎么想的。

跟独占模式比，还有一点需要注意的是，这里只有线程是head.next时（“老二”），才会去尝试获取资源，有剩余的话还会唤醒之后的队友。那么问题就来了，假如老大用完后释放了5个资源，而老二需要6个，老三需要1个，老四需要2个。老大先唤醒老二，老二一看资源不够，他是把资源让给老三呢，还是不让？答案是否定的！老二会继续park()等待其他线程释放资源，也更不会去唤醒老三和老四了。独占模式，同一时刻只有一个线程去执行，这样做未尝不可；但共享模式下，多个线程是可以同时执行的，现在因为老二的资源需求量大，而把后面量小的老三和老四也都卡住了。当然，这并不是问题，只是AQS保证严格按照入队顺序唤醒罢了（保证公平，但降低了并发）

###  setHeadAndPropagate(Node, int) ###

private void setHeadAndPropagate(Node node, int propagate) {
        Node h = head; 
        setHead(node);//head指向自己
         //如果还有剩余量，继续唤醒下一个邻居线程
        if (propagate > 0 || h == null || h.waitStatus < 0) {
            Node s = node.next;
            if (s == null || s.isShared())
                doReleaseShared();
        }
    }

此方法在setHead()的基础上多了一步，就是自己苏醒的同时，如果条件符合（比如还有剩余资源），还会去唤醒后继结点，毕竟是共享模式！

doReleaseShared()我们留着下一小节的releaseShared()里来讲。

tryAcquireShared()尝试获取资源，成功则直接返回；  
失败则通过doAcquireShared()进入等待队列park()，直到被unpark()/interrupt()并成功获取到资源才返回。整个等待过程也是忽略中断的。  
　　其实跟acquire()的流程大同小异，只不过多了个自己拿到资源后，还会去唤醒后继队友的操作，这才是共享

### releaseShared() ###

上一小节已经把acquireShared()说完了，这一小节就来讲讲它的反操作releaseShared()吧。此方法是共享模式下线程释放共享资源的顶层入口。它会释放指定量的资源，如果成功释放且允许唤醒等待线程，它会唤醒等待队列里的其他线程来获取资源。下面是releaseShared()的源码：

public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {//尝试释放资源
            doReleaseShared();//唤醒后继结点
            return true;
        }
        return false;
    }

此方法的流程也比较简单，一句话：释放掉资源后，唤醒后继。跟独占模式下的release()相似，但有一点稍微需要注意：独占模式下的tryRelease()在完全释放掉资源（state=0）后，才会返回true去唤醒其他线程，这主要是基于独占下可重入的考量；而共享模式下的releaseShared()则没有这种要求，共享模式实质就是控制一定量的线程并发执行，那么拥有资源的线程在释放掉部分资源时就可以唤醒后继等待结点。例如，资源总量是13，A（5）和B（7）分别获取到资源并发运行，C（4）来时只剩1个资源就需要等待。A在运行过程中释放掉2个资源量，然后tryReleaseShared(2)返回true唤醒C，C一看只有3个仍不够继续等待；随后B又释放2个，tryReleaseShared(2)返回true唤醒C，C一看有5个够自己用了，然后C就可以跟A和B一起运行。而ReentrantReadWriteLock读锁的tryReleaseShared()只有在完全释放掉资源（state=0）才返回true，所以自定义同步器可以根据需要决定tryReleaseShared()的返回值。

### doReleaseShared() ###

此方法主要用于唤醒后继。下面是它的源码：

private void doReleaseShared() {
        for (;;) {
            Node h = head;
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                if (ws == Node.SIGNAL) {
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue;
                    unparkSuccessor(h);//唤醒后继
                }
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;
            }
            if (h == head)// head发生变化
                break;
        }
    }

## 使用AQS重写自己的锁  ##

import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.AbstractQueuedSynchronizer;
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    
    public class MyLock2 implements Lock {
    
    	private Helper helper = new Helper();
    
    	private class Helper extends AbstractQueuedSynchronizer {
    
    		@Override
    		protected boolean tryAcquire(int arg) {
    
    			// 如果第一个线程进来，可以拿到锁，因此我们可以返回true
    
    			// 如果第二个线程进来，则拿不到锁，返回false。有种特例，如果当前进来的线程和当前保存的线程是同一个线程，则可以拿到锁，但是有代价，要更新状态值
    
    			// 如何判断是第一个线程进来还是其他线程进来？
    			int state = getState();
    			Thread t = Thread.currentThread();
    
    			if (state == 0) {
    				if (compareAndSetState(0, arg)) {
    					setExclusiveOwnerThread(t);
    					return true;
    				}
    			} else if (getExclusiveOwnerThread() == t) {
    				setState(state + 1);
    				return true;
    			}
    			return false;
    		}
    
    		@Override
    		protected boolean tryRelease(int arg) {
    
    			// 锁的获取和释放肯定是一一对应的，那么调用此方法的线程一定是当前线程
    
    			if (Thread.currentThread() != getExclusiveOwnerThread()) {
    				throw new RuntimeException();
    			}
    
    			int state = getState() - arg;
    
    			boolean flag = false;
    
    			if (state == 0) {
    				setExclusiveOwnerThread(null);
    				flag = true;
    			}
    
    			setState(state);
    
    			return flag;
    		}
    
    		Condition newCondition() {
    			return new ConditionObject();
    		}
    
    	}
    
    	@Override
    	public void lock() {
    		helper.acquire(1);
    	}
    
    	@Override
    	public void lockInterruptibly() throws InterruptedException {
    		helper.acquireInterruptibly(1);
    	}
    
    	@Override
    	public boolean tryLock() {
    		return helper.tryAcquire(1);
    	}
    
    	@Override
    	public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
    		return helper.tryAcquireNanos(1, unit.toNanos(time));
    	}
    
    	@Override
    	public void unlock() {
    		helper.release(1);
    	}
    
    	@Override
    	public Condition newCondition() {
    		return helper.newCondition();
    	}
    
    }

测试代码

public class Main {
    
    	private int value;
    	private MyLock2 lock = new MyLock2();
    
    	public int next() {
    		lock.lock();
    
    		try {
    			Thread.sleep(300);
    			return value++;
    		} catch (InterruptedException e) {
    			throw new RuntimeException();
    		} finally {
    			lock.unlock();
    		}
    	}
    
    	public void a() {
    		lock.lock();
    		System.out.println("a");
    		b();
    		lock.unlock();
    	}
    
    	public void b() {
    		lock.lock();
    		System.out.println("b");
    		lock.unlock();
    	}
    
    	public static void main(String[] args) {
    
    		Main m = new Main();
    		//测试锁重入
    		new Thread(new Runnable() {
    
    			@Override
    			public void run() {
    				m.a();
    			}
    		}).start();
    
    		//测试线程安全性问题
    		new Thread(new Runnable() {
    			@Override
    			public void run() {
    				while (true) {
    					System.out.println(Thread.currentThread().getName() + " " + m.next());
    				}
    			}
    		}).start();
    		new Thread(new Runnable() {
    			@Override
    			public void run() {
    				while (true) {
    					System.out.println(Thread.currentThread().getName() + " " + m.next());
    				}
    			}
    		}).start();
    	}
    }

[JDK]: http://tool.oschina.net/apidocs/apidoc?api=jdk-zh
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2llZmxleA_size_16_color_FFFFFF_t_70]: /images/20220325/ac8efd7a54644f368bcea810b1c70d05.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2llZmxleA_size_16_color_FFFFFF_t_70 1]: /images/20220325/8f9af5b99a2c4eb6a3d7547a37d89218.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2llZmxleA_size_16_color_FFFFFF_t_70 2]: /images/20220325/3380dcbd0bd8447782ea4492baacef0d.png