什么是“重入”
Re-Entrant-Lock 翻译成重入锁也是非常贴切的。之所以这么叫，那是因为这种锁是可以反复进入的。当然，这里的反复仅仅局限于一个线程，观察下面的代码， f1 锁住 lock 之后， f2 依然能继续获取到 lock 并执行，因为它们都属于主线程。
public class Main {
static class Test {
private final ReentrantLock lock = new ReentrantLock();
public void f1() {
lock.lock();
try {
System.out.println(Thread.currentThread().getName());
f2();
} finally {
lock.unlock();
}
}
public void f2() {
lock.lock();
try {
System.out.println(Thread.currentThread().getName());
} finally {
lock.unlock();
}
}
}
public static void main(String[] args) {
Test test = new Test();
test.f1();
}
}
重入锁 VS synchronized
重入锁可以完全替代 synchronized 关键字。在 JDK 5.0 的早期版本中，重入锁的性能远远好于 synchronized ，但从 JDK 6.0 开始，JDK 在 synchronized 上做了大量的优化，使得两者的性能差距并不大。
用两种方法分别实现 num++：
重入锁
public class Main {
static int num = 0;
static ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) throws InterruptedException {
Thread[] ts = new Thread[32];
Runnable runnable = () -> {
for (int i = 0; i < 10000; i++) {
lock.lock();
try {
num++;
} finally {
lock.unlock();
}
}
};
for (int i = 0; i < 32; i++) {
ts[i] = new Thread(runnable);
ts[i].start();
}
for (int i = 0; i < 32; i++) {
ts[i].join();
}
System.out.println(num);
}
}
synchronized
public class Main {
static int num = 0;
static Object obj = new Object();
public static void main(String[] args) throws InterruptedException {
Thread[] ts = new Thread[32];
Runnable runnable = () -> {
for (int i = 0; i < 10000; i++) {
synchronized (obj) {
num++;
}
}
};
for (int i = 0; i < 32; i++) {
ts[i] = new Thread(runnable);
ts[i].start();
}
for (int i = 0; i < 32; i++) {
ts[i].join();
}
System.out.println(num);
}
}
响应中断
对于 synchronized 来说，如果一个线程在等待锁，那么结果只有两种情况，要么它获得这把锁继续执行，要么它就保持等待。而使用重入锁，则提供另外一种可能，那就是线程可以被中断。
模拟一个死锁的场景：两个线程都需要获取 lock1, lock2 两把锁，线程 t1 先获取了 lock1 ，线程 t2 先获取了 lock2 ，然后它们就开始无限等待对方让出锁。但是这个时候，如果中断了线程 t2 ，并且释放 t2 占有的锁， t1 就能正常运行：
public class Main {
static class IntLock implements Runnable {
private static ReentrantLock lock1 = new ReentrantLock();
private static ReentrantLock lock2 = new ReentrantLock();
private int lock;
public IntLock(int lock) {
this.lock = lock;
}
@Override
public void run() {
try {
if (lock == 1) {
lock1.lockInterruptibly();
try {
Thread.sleep(500);
lock2.lockInterruptibly();
try {
System.out.println("t1成功获取两把锁");
} finally {
lock2.unlock();
}
} catch (InterruptedException e) {
System.out.println("t1被中断");
Thread.currentThread().interrupt();
} finally {
lock1.unlock();
}
} else {
lock2.lockInterruptibly();
try {
Thread.sleep(500);
lock1.lockInterruptibly();
try {
System.out.println("t2成功获取两把锁");
} finally {
lock1.unlock();
}
} catch (InterruptedException e) {
System.out.println("t2被中断");
Thread.currentThread().interrupt();
} finally {
lock2.unlock();
}
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
public static void main(String[] args) throws InterruptedException {
IntLock r1 = new IntLock(1);
IntLock r2 = new IntLock(2);
Thread t1 = new Thread(r1);
Thread t2 = new Thread(r2);
t1.start();
t2.start();
Thread.sleep(1000);
t2.interrupt();
}
}
锁申请等待限时
tryLock() 方法接收两个参数，一个表示等待时长，另外一个表示计时单位。也可以不带参数直接运行。在这种情况下，当前线程会尝试获得锁，如果锁并未被其他线程占用，则申请锁会成功，并立即返回 true 。如果锁被其他线程占用，则当前线程不会进行等待，而是立即返回 false。
public class Main {
private static ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) {
Runnable target = () -> {
try {
if (lock.tryLock(1, TimeUnit.SECONDS)) {
System.out.println(Thread.currentThread().getName() + " get lock success");
Thread.sleep(4000);
} else {
System.out.println(Thread.currentThread().getName() + " get lock failed");
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
if (lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
};
Thread t1 = new Thread(target);
Thread t2 = new Thread(target);
t1.start();
t2.start();
}
}
公平锁
在大多数情况下，锁的申请都是非公平的。也就是说，线程 1 首先请求了锁 A，接着线程 2 也请求了锁 A。那么当锁 A 可用时，是线程 1 可以获得锁还是线程 2 可以获得锁呢？这是不一定的。系统只是会从这个锁的等待队列中随机挑选一个。因此不能保证其公平性。这就好比买票不排队，大家都乱哄哄得围在售票窗口前，售票员忙得焦头烂额，也顾不及谁先谁后，随便找个人出票就完事了。而公平的锁，则不是这样，它会按照时间的先后顺序，保证先到者先得，后到者后得。公平锁的一大特点是：它不会产生饥饿现象。只要你排队，最终还是可以等到资源的。如果我们使用 synchronized 关键字进行锁控制，那么产生的锁就是非公平的。而重入锁允许我们对其公平性进行设置。它有一个如下的构造函数：
public ReentrantLock(boolean fair)
当参数 fair 为 true 时，表示锁是公平的。公平锁看起来很优美，但是要实现公平锁必然要求系统维护一个有序队列，因此公平锁的实现成本比较高，性能相对也非常低下，因此，默认情况下，锁是非公平的。如果没有特别的需求，也不需要使用公平锁。公平锁和非公平锁在线程调度表现上也是非常不一样的。下面的代码可以很好地突出公平锁的特点：
public class Main {
private static ReentrantLock fairLock = new ReentrantLock(true);
public static void main(String[] args) throws InterruptedException {
Runnable target = () -> {
while (!Thread.currentThread().isInterrupted()) {
fairLock.lock();
try {
System.out.println(Thread.currentThread().getName() + " 获得锁");
} finally {
fairLock.unlock();
}
}
};
Thread t1 = new Thread(target);
Thread t2 = new Thread(target);
t1.start();
t2.start();
Thread.sleep(1000);
t1.interrupt();
t2.interrupt();
}
}
从运行结果可以看出，大部分情况下，两个线程是交替运行的。
...
Thread-0 获得锁
Thread-1 获得锁
Thread-0 获得锁
Thread-1 获得锁
Thread-0 获得锁
Thread-1 获得锁
Thread-0 获得锁
Thread-1 获得锁
Thread-0 获得锁
...
Thread-0 获得锁
Thread-1 获得锁
Thread-0 获得锁
Thread-1 获得锁
Thread-0 获得锁
...
但是换成非公平锁之后，会发现连续多次都是同一个线程获取锁。
...
Thread-0 获得锁
Thread-0 获得锁
Thread-0 获得锁
Thread-0 获得锁
Thread-0 获得锁
Thread-0 获得锁
...
Thread-1 获得锁
Thread-1 获得锁
Thread-1 获得锁
Thread-1 获得锁
Thread-1 获得锁
Thread-1 获得锁
Thread-1 获得锁
...
