同花顺

物竞天择，优胜劣汰。

大自然的生存法则，在Java里也异常适用。

ReentrantLock默认就是采用非公平锁，让线程们自己去竞争。

初中时，学校食堂打饭插队现象，屡禁不止，这就是不公平的。

有些强壮的小伙子，每次都插队，每次都能吃到饭。

可怜的小老犇，老老实实的排队，他们都吃完了，才轮到我，然后正好没饭了，饿肚子吧。

源码分析

瞅瞅ReentrantLock的源码，大体上能看懂，就明白公平锁和非公平锁是如何实现的了。

在注释里，我把一些鸟文都去掉了，剩下的都是能看懂的。

ReentrantLock类里一共由三部分组成。

• ReentrantLock类中有三个内部类。
• Sync：继承AQS。
• NonfairSync:继承Sync。
• FairSync：继承Sync。

package java.util.concurrent.locks;
import java.util.concurrent.TimeUnit;
import java.util.Collection;

public class ReentrantLock implements Lock, java.io.Serializable {


  //首先，就是我们最经常使用的构造方法，默认使用的都是非公平锁。
  //NofairSync，就是不公平锁的意思。
  public ReentrantLock() {
        sync = new NonfairSync();
    }

    //这里,你也可以构造一个公平锁出来,传递true参数即可。
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }


    //下边这么长，是一个内部类Sync。
    //我们的公平锁，非公平锁都是集成Sync，自然里边的方法都可以用。
    //很长，不用看，看下边的公平锁和非公平锁就可以。
    abstract static class Sync extends AbstractQueuedSynchronizer {
    
		//非公平锁就是这个，非公平锁类里判断能不能获取锁就是通过这个方法搞的。
		//将非公平锁的这个方法，与公平锁的这个方法一对比。
		//其意自现。
        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            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 NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        /**
        这里可以看到这个方法compareAndSetState()
        比较并改变状态，简称CAS，这个和CAS思想是一样的。
        看看state是不是0，是0的话就修改状态为1.
        并获取锁，设置锁线程为当前自己线程。**/

		//非公平锁的lock方法
		//如果执行成功，则获取锁，失败，则执行acquire(1)方法。
		//acquire()方法在AbstractQueuedSynchronizer内部。
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }
        
		//这里非公平锁调用了父类Sync里的方法，判断是否可以进入获取锁。
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

   //公平锁
    static final class FairSync extends Sync {

		//上锁，修改状态state为1。
        final void lock() {
            acquire(1);
        }
		//在多线程竞争锁的时候，谁能获取小红的欢心，获取锁就是这个方法。
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
            	//非公平锁那里的判断是两个
            	//公平锁这里的判断是三个判断
            	//相比非公平锁，这里多了一个判断，判断一下自己本线程是否在等待队列的首部。
            	//另外两个操作一样，都是CAS操作以及获取锁操作。
                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;
        }
    }

  
    //这里是ReentrantLock的方法，可以看到它使用的是内部类Sync的方法。
    //所以使用ReentrantLock时，下边很多方法都是Sync的，其实就是使用的Sync。
    //默认使用的都是非公平锁的lock()方法。
    public void lock() {
        sync.lock();
    }

   //统一都是Sync的方法。
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

    //统一都是Sync的方法。
    public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }

    //统一都是Sync的方法。
    public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }

    //统一都是Sync的方法。
    public void unlock() {
        sync.release(1);
    }

    //统一都是Sync的方法。
    public Condition newCondition() {
        return sync.newCondition();
    }
    
    //统一都是Sync的方法。
    public boolean isLocked() {
        return sync.isLocked();
    }

  	//统一都是Sync的方法。
    public final boolean isFair() {
        return sync instanceof FairSync;
    }

  	//统一都是Sync的方法。
    protected Thread getOwner() {
        return sync.getOwner();
    }

    //统一都是Sync的方法。
    public final boolean hasQueuedThreads() {
        return sync.hasQueuedThreads();
    }

    //统一都是Sync的方法。
    public final boolean hasQueuedThread(Thread thread) {
        return sync.isQueued(thread);
    }

    //统一都是Sync的方法。
    public final int getQueueLength() {
        return sync.getQueueLength();
    }

    //统一都是Sync的方法。
    protected Collection<Thread> getQueuedThreads() {
        return sync.getQueuedThreads();
    }

    //统一都是Sync的方法。
    public boolean hasWaiters(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition);
    }

    //统一都是Sync的方法。
    public int getWaitQueueLength(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)condition);
    }

    //统一都是Sync的方法，看似你使用的是ReentrantLock但是实际上内部已经被Sync腐蚀了。
    protected Collection<Thread> getWaitingThreads(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.getWaitingThreads((AbstractQueuedSynchronizer.ConditionObject)condition);
    }

   
    public String toString() {
        Thread o = sync.getOwner();
        return super.toString() + ((o == null) ?
                                   "[Unlocked]" :
                                   "[Locked by thread " + o.getName() + "]");
    }
}

执行流程

非公平锁

1、各个线程争夺CPU的执行权，线程小王争夺到了。

2、观察state为0，执行CAS操作，修改状态，修改持有线程为小王，并获取锁。

3、小王完事了，该小绿上场了，小绿观察state为0，我要进去了。

4、小绿在即将进去的那一刻，老王给他戴了帽子，因为老王也观察到state为0，身为老司机当然要比小绿厉害了。

5、小王获得锁。

公平锁

1、各个线程争夺CPU的执行权，线程小王争夺到了。

2、观察state为0，执行CAS操作，修改状态，修改持有线程为小王，并获取锁。

3、小王完事了，该小绿上场了，小绿观察state为0，我要进去了。

4、小绿在即将进去的那一刻，老王想给他戴帽子，但是老王的距离太短了，他是等待队列中的二号位，只有一号位才能给别人戴帽子。

5、小绿获得锁。

公平锁的实现多了一步，线程判断一下自己在不在队列的首位。

在首位，则获取锁。不在首位，等着吧。

有什么不同

公平锁与非公平锁就是等待队列中的线程排队不排队的问题。

公平锁/非公平锁优劣

公平锁

优点：大锅饭，统一分配资源。

缺点：性能下降很多，第一个线程释放锁后，如果还想再次获取锁，需要进入等待队列尾部，重新排队，进入阻塞状态，等待CPU唤醒。

非公平锁

优点：强者恒强，性能高。

缺点：弱者恒弱，抢不到饭吃。

强大的线程，弱小的线程，弱小的不行啊，一直抢不到。

为什么非公平锁的性能优于公平锁

参考：

这篇文章有详细的代码测试。

https://blog.csdn.net/qq_34436819/article/details/102869353

最后

以上就是无语钥匙为你收集整理的【锁】ReentrantLock如何实现公平锁/非公平锁同花顺源码分析执行流程有什么不同公平锁/非公平锁优劣为什么非公平锁的性能优于公平锁的全部内容，希望文章能够帮你解决【锁】ReentrantLock如何实现公平锁/非公平锁同花顺源码分析执行流程有什么不同公平锁/非公平锁优劣为什么非公平锁的性能优于公平锁所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。