可重入互斥锁ReentrantLock类

JUC框架中最常用的锁ReentrantLock(可重入独占锁，也叫可重入互斥锁)。

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

ReentrantLock实现Lock接口，以及Serializable可序列化接口。

可重入独占锁的意思：

同一时间只能有一个线程持有这个锁。

持有这个锁的线程可以再次进入另一个被这个锁锁住的模块，即持有这个锁的线程可以重复获取锁。

Lock接口

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

public interface Lock {

    // 获取锁，如果获取不到，就一直等待。不响应中断请求
    void lock();

    // 获取锁，如果获取不到，就一直等待。如果在线程等待期间有中断请求就抛出异常
    void lockInterruptibly() throws InterruptedException;

    // 尝试用非公平锁方式去获取锁，立即返回。返回true表示获取成功，返回false表示获取失败
    boolean tryLock();

    // 在规定的unit时间内获取锁，如果时间到了还没有获取到锁，则返回false，表示获取失败
    // 如果在线程等待期间有中断请求就抛出异常
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    // 当前线程释放占用的锁，并唤醒这个锁上的一个等待线程
    void unlock();

    // 创建一个Condition对象
    Condition newCondition();
}

这个接口提供获取锁，释放锁以及生成Condition对象的方法。

构造函数和成员属性

成员属性

// ReentrantLock通过sync变量，实现独占锁的操作。
//Sync是AbstractQueuedSynchronizer的子类
private final Sync sync;

ReentrantLock只有这一个成员变量，它是AQS的子类，所以可以通过sync实现独占锁的操作。

构造函数

// 默认创建的是非公平锁
public ReentrantLock() {
    sync = new NonfairSync();
}

// 根据fair值，决定创建公平锁还是非公平锁
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

根据参数fair来决定是公平锁还是非公平锁，默认是非公平锁。

Sync内部抽象类

这个类也是个抽象类，它的两个子类就是FairSync和NonfairSync。有两个重要方法。

nonfairTryAcquire方法

使用非公平方式去尝试获取锁

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    // 获取锁的记录状态state
    int c = getState();
    // 如果c==0表示当前锁是空闲的
    if (c == 0) {
        // 通过CAS原子操作方式设置锁的状态，如果为true，表示当前线程获取的锁，
        // 为false，锁的状态被其他线程更改，当前线程获取的锁失败
        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;
}

方法流程：

调用getState方法获取锁的记录状态c
如果c==0表示当前锁是空闲的。因为是非公平的方法获取锁，所以直接调用compareAndSetState更改锁的状态，如果成功，表示当前线程获取了锁，如果失败，表示锁的状态别的线程更改了，当前线程获取锁失败。
如果c不等于0，那么要看当前线程是不是获取锁的线程，因为ReentrantLock是可重入锁，获取锁的线程可以重复获取锁。

tryRelease方法

尝试释放锁资源，返回true表示完全释放了锁资源，返回false表示还持有锁资源。

因为锁是可重入的，所以锁可能要释放多次。

protected final boolean tryRelease(int releases) {
    // c表示新的锁的记录状态
    int c = getState() - releases;
    // 如果当前线程不是独占锁的线程，就抛出IllegalMonitorStateException异常
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    // 标志是否可以释放锁
    boolean free = false;
    // 当新的锁的记录状态为0时，表示可以释放锁
    if (c == 0) {
        free = true;
        // 设置独占锁的线程为null
        setExclusiveOwnerThread(null);
    }
    setState(c);
    return free;
}

方法流程：

先计算新的锁的记录状态c。
如果当前线程不是独占锁的线程，就抛出IllegalMonitorStateException异常。
当新的锁的记录状态为0时，表示完全释放锁资源，就唤醒另一个等待锁的线程了。
设置新的锁的记录状态。

NonfairSync非公平锁

/**
 * 非公平锁
 */
static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;

    // 获取锁，如果没有获取到锁，则当前线程要阻塞等待
    final void lock() {
        // compareAndSetState返回true，表示当前线程获取锁成功。
        // 因为是非公平锁，所以不需要判断AbstractQueuedSynchronizer线程等待队列是否有值
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            // 调用acquire方法，获取锁
            acquire(1);
    }

    // 尝试获取锁，获取到锁返回true，没有获取到返回false
    protected final boolean tryAcquire(int acquires) {
        // 调用父类的nonfairTryAcquire方法
        return nonfairTryAcquire(acquires);
    }
}

继承Sync类需要复写两个方法：

lock获取锁的方法。因为是非公平锁方式获取锁，所以先直接调用compareAndSetState方法，如果返回true，表示锁资源被当前线程持有了。返回false表示锁的状态state不是0，锁资源已经被持有了。则调用acquire方法，再次获取锁，不成功就阻塞当前线程。
tryAcquire方法：尝试获取锁，获取到锁返回true，没有获取到返回false。这里调用父类的nonfairTryAcquire方法

FairSync公平锁

/**
 * 公平锁
 */
static final class FairSync extends Sync {
    private static final long serialVersionUID = -3000897897090466540L;

    final void lock() {
        // 与非公平锁不同，因为它要考虑线程等待队列是否有值
        acquire(1);
    }

    // 尝试获取锁，与与非公平锁最大的不同就是调用hasQueuedPredecessors()方法
    // hasQueuedPredecessors方法返回true，表示等待线程队列中有一个线程在当前线程之前，
    // 根据公平锁的规则，当前线程不能获取锁。
    protected final boolean tryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        // 获取锁的记录状态
        int c = getState();
        // 如果c==0表示当前锁是空闲的
        if (c == 0) {
            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;
    }
}

lock 方法：与非公平锁相比，它直接调用acquire方法，因为是公平锁，所以必须考虑当前线程是不是CLH队列中第一个(即队列中第一个等待线程)
tryAcquire 方法：与非公平锁相比，会调用调用hasQueuedPredecessors()方法。 hasQueuedPredecessors方法返回true，表示等待线程队列中有一个线程在当前线程之前，根据公平锁的规则，当前线程不能获取锁。

代码演示

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockTest {

    public static void newThread(Lock lock, String name, int time) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程"+Thread.currentThread().getName()+" 开始运行，准备获取锁");
                lock.lock();
                try {
                    System.out.println("====线程"+Thread.currentThread().getName()+" 在run方法中获取了锁");
                    lockAgain();
                    try {
                        Thread.sleep(time);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } finally {
                    System.out.println("----线程"+Thread.currentThread().getName()+" 在run方法中释放了锁");
                    lock.unlock();
                }
            }

            private void lockAgain() {
                lock.lock();
                try {
                    System.out.println("====线程"+Thread.currentThread().getName()+"  在lockAgain方法中再次获取了锁");
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } finally {
                    System.out.println("----线程"+Thread.currentThread().getName()+" 在lockAgain方法中释放了锁");
                    lock.unlock();
                }
            }
        },name).start();
    }

    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        newThread(lock, "t1111", 1000);
        newThread(lock, "t2222", 1000);
        newThread(lock, "t3333", 1000);
    }
}

从这个例子中可以看出ReentrantLock是一个可重入锁，当前持有锁的线程可以进入另一个被锁住的模块，而且只有都释放完成之后，它才会去唤醒一个等待锁的线程。

注意一个有趣点，虽然我们创建的非公平锁，但是每次释放锁完成后，去唤醒一个等待线程时，你会发现它一定是等待线程中的第一个线程。那么不是和非公平锁定义好像不一样啊。
其实非公平锁和公平锁最大的区别是，当锁是空闲的即没有任何线程持有锁，非公平锁就允许当前线程直接获取锁，而不用考虑是否有其他线程已经在等待这把锁了。而公平锁不是这样，如果有等待线程队列，那么就将当前线程插入到等待线程队列尾。

输出结果是：

线程t1111 开始运行，准备获取锁
====线程t1111 在run方法中获取了锁
====线程t1111  在lockAgain方法中再次获取了锁
线程t2222 开始运行，准备获取锁
线程t3333 开始运行，准备获取锁
----线程t1111 在lockAgain方法中释放了锁
----线程t1111 在run方法中释放了锁
====线程t2222 在run方法中获取了锁
====线程t2222  在lockAgain方法中再次获取了锁
----线程t2222 在lockAgain方法中释放了锁
----线程t2222 在run方法中释放了锁
====线程t3333 在run方法中获取了锁
====线程t3333  在lockAgain方法中再次获取了锁
----线程t3333 在lockAgain方法中释放了锁
----线程t3333 在run方法中释放了锁

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class WaitTest {
    private Lock lock;
    private Condition condition;

    public WaitTest() {
        this.lock = new ReentrantLock();
        this.condition = this.lock.newCondition();
    }

    public void waitTest() {
        lock.lock();
        try {
            System.out.println("===线程"+Thread.currentThread().getName()+" 获取了锁");
            try {
                Thread.sleep(1000);
                System.out.println("========线程"+Thread.currentThread().getName()+"  调用await方法 等待并释放了锁");
                this.condition.await();
                System.out.println("========线程"+Thread.currentThread().getName()+"  await等待被唤醒");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } finally {
            System.out.println("---线程"+Thread.currentThread().getName()+"  释放锁");
            lock.unlock();
        }
    }

    public void signalTest() {
        lock.lock();
        try {
            System.out.println("===线程"+Thread.currentThread().getName()+"  获取了锁");
            System.out.println("-------线程"+Thread.currentThread().getName()+"  调用signal方法");
            this.condition.signal();
        } finally {
            System.out.println("---线程"+Thread.currentThread().getName()+"  释放锁");
            lock.unlock();
        }
    }

}

public class LockWaitTest {

    public static void newThread(WaitTest waitTest, String name, boolean isWait) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                if (isWait) waitTest.waitTest();
                else waitTest.signalTest();
            }
        },name).start();
    }

    public static void main(String[] args) {
        WaitTest waitTest = new WaitTest();
        newThread(waitTest, "t1111", true);
        newThread(waitTest, "t2222", false);
//        newThread(waitTest, "t3333", true);
//        newThread(waitTest, "t4444", false);
    }
}