java并发编程---ReentrantLock公平锁实现原理

忘是亡心i 2023-07-12 05:16 1阅读 0赞

### 文章目录 ###

*  java并发编程---ReentrantLock公平锁实现原理
 *   *  先看非公平锁
     *  公平锁的实现
 *  参考资料

# java并发编程—ReentrantLock公平锁实现原理 #

如果一个线程组里，能保证每个线程都能拿到锁，那么这个锁就是公平锁。相反，如果保证不了每个线程都能拿到锁，也就是存在有线程饿死，那么这个锁就是非公平锁。

## 先看非公平锁 ##

![在这里插入图片描述][format_png]

static final class NonfairSync extends Sync { 
            final void lock() { 
                if (compareAndSetState(0, 1))
                    setExclusiveOwnerThread(Thread.currentThread());
                else
                    acquire(1);
            }

public final void acquire(int arg) { 
            if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
                selfInterrupt();
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2U4OTEzNzc_size_16_color_FFFFFF_t_70]

protected final boolean tryAcquire(int acquires) { 
                return nonfairTryAcquire(acquires);
            }

非公平锁最后调用nonfairTryAcquire方法

final boolean nonfairTryAcquire(int acquires) { 
                final Thread current = Thread.currentThread();
                int c = getState();
                //如果还没有获得锁
                if (c == 0) { 
                	//尝试用cas获得，这里体现了非公平性：不去检查AQS队列
                    if (compareAndSetState(0, acquires)) { 
                        setExclusiveOwnerThread(current);
                        return true;
                    }
                }
                //如果已经获得了锁，线程还是当前线程，表示发生`static final class FairSync extends Sync {了锁重入
                else if (current == getExclusiveOwnerThread()) { 
                    int nextc = c + acquires;
                    if (nextc < 0) // overflow
                        throw new Error("Maximum lock count exceeded");
                    setState(nextc);
                    return true;
                }
                //获取失败，回到调用处
                return false;
            }

## 公平锁的实现 ##

static final class FairSync extends Sync { 
    final void lock() { 
                acquire(1);
            }

public final void acquire(int arg) { 
            if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
                selfInterrupt();
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2U4OTEzNzc_size_16_color_FFFFFF_t_70 1]

//与非公平锁主要区别在于tryAcquire方法的实现
            protected final boolean tryAcquire(int acquires) { 
                final Thread current = Thread.currentThread();
                int c = getState();
                if (c == 0) { 
                	//先检查AQS队列中是否有前驱节点，没有才去竞争
                    if (!hasQueuedPredecessors() &&
                        compareAndSetState(0, acquires)) { 
                        setExclusiveOwnerThread(current);
                        return true;
                    }
                }
                else if (current == getExclusiveOwnerThread()) { 
                    int nextc = c + acquires;
                    if (nextc < 0)
                        throw new Error("Maximum lock count exceeded");
                    setState(nextc);
                    return true;
                }
                return false;
            }

这里`hasQueuedPredecessors()`不成立才会去调用`compareAndSetState`，去抢线程。如果`hasQueuedPredecessors()`成立，相当于队列中有其他的线程，下面的`compareAndSetState`就不会执行。  
注意`&&` 是短路运算。

//判断队列中是否有一个前驱的节点
        public final boolean hasQueuedPredecessors() { 
            Node t = tail; // Read fields in reverse initialization order
            Node h = head;
            Node s;
            // h != t 时表示队列中有Node
            return h != t &&
            	//情况一，(s = h.next) == null 表示队列中还没有老二
            	//情况二，队列中老二线程不是此线程 
                ((s = h.next) == null || s.thread != Thread.currentThread());						
        }

头不等于尾，队列中有节点。  
队列中还没有老二，队列中老二线程不是此线程，则返回`true`。  
这说明队列中有优先级比你高的线程在等待，则不会往下去执行竞争锁`compareAndSetState(0, acquires))`。

# 参考资料 #

http://www.codeceo.com/article/reentrantlock-learn.html

[format_png]: https://imgconvert.csdnimg.cn/aHR0cDovL3N0YXRpYy5jb2RlY2VvLmNvbS9pbWFnZXMvMjAxNi8wOC9yZWVudHJhbnRsb2NrMDIucG5n?x-oss-process=image/format,png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2U4OTEzNzc_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200307115856644.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2U4OTEzNzc=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2U4OTEzNzc_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200307120605816.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2U4OTEzNzc=,size_16,color_FFFFFF,t_70