关于java中ReentrantLock类的源码分析以及总结与例子

一，官方描述

reentrant是一个跟synchronized具有相同行为和语义的持有锁来访问方法和语句的互斥锁，但是reentrant还拥有被扩展的能力。

ReentrantLock会被线程拥有并且持续锁定，不会解锁。线程调用lock()方法返回后，则成功持有锁，否则这个锁正在被另一个线程所持有，只能等待另一个线程释放锁，如果当前线程拥有了锁，则调用lock()方法会立即返回，这个状态可以通过isHeldByCurrentThread和getHoldCount方法。

这个类的构造器可以接受一个可选的参数，如果被设置为true,锁会准许线程等待最长的时间。另外，锁不会保证特别的访问顺序。程序被许多线程通过公平锁访问可能会降低整体的吞吐量，而不是使用默认的设置，而且有更小的差异及时获得锁以及确保不会存在饥饿。注意，无论如何，锁的公平性不保证线程计划的公平性。因此，许多线程使用公平锁也许在其他活动线程没有处理并且自己没有持有该锁的时候，其中的一个线程会接连的多次获得这个锁。还有要注意，不定期的tryLock方法不会遵守公平设置，如果这个锁是有效的甚至如果其他线程都在等待，他也将成功获得锁。

强烈建议在实践中总是在try块中立即调用lock方法，最典型的before/after结构如下：

class X {
    private final ReentrantLock lock = new ReentrantLock();
    public void run() {
        lock.lock();
        try {
        
        } finally {
            lock.unlock();
        }
    }
}

二，源码分析

在FairSync类的tryAcquire方法中，有一个if判断isFirst，这就是判断当前请求线程是否为队列中的第一个线程，如果是，则获取锁，如果不是，则跳过。

两者都有lock方法，但是实现却有一些不同，对于NonfairSync，其实现如下：

final void lock() {
           if (compareAndSetState(0, 1))   //关键在于这里。这里的意思是说，如果当前锁的状态如果是0,则就给这个线程锁
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
}

FairSync类的代码如下：

final void lock() {
    acquire(1);  //这里就是要通过队列来给线程分配锁
}

三，总结

四，例子

package test;

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockTest {
    private static final ReentrantLock lock = new ReentrantLock();
    private static final ReentrantLock fairlock = new ReentrantLock(true);
    private int n;
    public static void main(String[] args) {
        ReentrantLockTest rlt = new ReentrantLockTest();
        for(int i = 0; i < 100; i++) {
            Thread nonT = new Thread(new NonFairTestThread(rlt));
            nonT.setName("nonFair[" + (i + 1) + "]");
            nonT.start();
            
            Thread fairT = new Thread(new FairTestThread(rlt));
            fairT.setName("fair[" + (i + 1) + "]");
            fairT.start();
        }
    }
    //非公平锁
    static class NonFairTestThread implements Runnable {
        private ReentrantLockTest rlt;
        public NonFairTestThread(ReentrantLockTest rlt) {
            this.rlt = rlt;
        }
        
        public void run() {
            lock.lock();
            try {
                rlt.setNum(rlt.getNum() + 1);
                System.out.println(Thread.currentThread().getName() + " nonfairlock***************" + rlt.getNum());
            } finally {
                lock.unlock();
            }
            
        }
    }
    //公平锁
    static class FairTestThread implements Runnable {
        private ReentrantLockTest rlt;
        public FairTestThread(ReentrantLockTest rlt) {
            this.rlt = rlt;

        }
        
        public void run() {
            fairlock.lock();
            try {
                rlt.setNum(rlt.getNum() + 1);
                System.out.println(Thread.currentThread().getName() + "   fairlock=======" + rlt.getNum() + 
                        "   " + fairlock.getHoldCount() + " queuelength=" + fairlock.getQueueLength());
            } finally {
                fairlock.unlock();
            }
            
        }
    }
    
    public void setNum(int n) {
        this.n = n;
    }
    
    public int getNum() {
        return n;
    }
}

关于java中ReentrantLock类的源码分析以及总结与例子