重入锁可以完全替代synchronized关键字。使用java.util.concurrent.locks.ReentrantLock类实现，下面是一个重入锁的简单例子：
package cn.net.bysoft.java.concurrency.design.ch03;
import java.util.concurrent.locks.ReentrantLock;
public class Example1 implements Runnable {
public static ReentrantLock lock = new ReentrantLock();
public static int i = 0;
public static void main(String[] args) throws InterruptedException {
Example1 exp = new Example1();
Thread t1 = new Thread(exp);
Thread t2 = new Thread(exp);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(i);
}
@Override
public void run() {
for (int j = 0; j < 1000000; j++) {
lock.lock();
try {
i++;
} finally {
lock.unlock();
}
}
}
}
使用重入锁保护临界区资源i，确保多线程对i操作的安全性。与synchronized相比，重入锁有着显示的操作过程。开发人员必须手动指定何时加锁，何时释放锁。也正因为这样，重入锁对逻辑控制的灵活性要远远好于synchronized。但在退出临界区时，必须记得释放锁。
1.1 中断响应
对于synchronized来说，如果一个线程在等待锁，那么结果只有两种，要么获得锁，要么就保持等待。而使用重入锁，则提供另一种可能，那就是线程可以被中断。
比如你和朋友约好去打球，如果你等了半小时，朋友还没到，然后你接到一个电话，说不能如约了，那么你就可以打道回府了。
中断正式提供了一套类似的机制。如果一个线程正在等待锁，那么它依然可以收到一个通知，被告知无需再等待，可以停止工作了。这种情况对死锁有一定的帮助。
下面的代码产生了一个死锁，但得益于锁中断，我们可以很轻松地解锁这个死锁：
package cn.net.bysoft.java.concurrency.design.ch03;
import java.util.concurrent.locks.ReentrantLock;
public class Example2 implements Runnable {
public static ReentrantLock lock1 = new ReentrantLock();
public static ReentrantLock lock2 = new ReentrantLock();
int lock;
public Example2(int lock) {
this.lock = lock;
}
public static void main(String[] args) throws InterruptedException {
Example2 emp1 = new Example2(1);
Example2 emp2 = new Example2(2);
Thread t1 = new Thread(emp1);
Thread t2 = new Thread(emp2);
t1.start();
t2.start();
Thread.sleep(1000);
t2.interrupt();
}
@Override
public void run() {
try {
if (lock == 1) {
lock1.lockInterruptibly();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
}
lock2.lockInterruptibly();
} else {
lock2.lockInterruptibly();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
}
lock1.lockInterruptibly();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if(lock1.isHeldByCurrentThread())
lock1.unlock();
if(lock2.isHeldByCurrentThread())
lock2.unlock();
System.out.println(Thread.currentThread().getId() + ": 线程退出");
}
}
}
线程t1和t2启动后，t1先占用lock1，再占用lock2；t2先占用lock2，在请求lock1。因此很容易形成t1和t2的互相等待。使用lockInterruptiblu()方法，这是一个可以对中断进行响应的锁申请动作，即在等待锁的过程中，可以响应中断。
1.2 锁申请等待限时
出了等待外部中断通知，要避免死锁还有另一种方法，那就是限时等待。还是以打球为例，如果朋友迟迟不来，又无法联系到他，那么，在等待1，2个小时后，就可以打道回府了。
对于线程来说，通常，我们无法判断为什么一个线程迟迟拿不到锁。也许是因为死锁了，也许是因为产生了饥饿。但如果给定一个等待时间，让线程主动放弃，那么对系统来说是有意义的，可以使用tryLock()方法进行一次限时等待：
package cn.net.bysoft.java.concurrency.design.ch03;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
public class Example3 implements Runnable {
public static ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) {
Example3 exp = new Example3();
Thread t1 = new Thread(exp);
Thread t2 = new Thread(exp);
t1.start();
t2.start();
}
@Override
public void run() {
try {
if (lock.tryLock(5, TimeUnit.SECONDS))
Thread.sleep(6000);
else
System.out.println("get lock failed");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if (lock.isHeldByCurrentThread())
lock.unlock();
}
}
}
tryLock()方法接收两个参数，一个表示等待时长，一个表示计时单位。如果超过时间还没有得到锁，返回false，如果成功获得锁，则返回true。
tryLock()方法也可以不输入参数直接运行。在这种情况下，当前线程会尝试获得锁，如果锁并未被其他线程占用，则申请成功，并立即返回true。如果获得不到锁，则不会进行等待，立即返回false。这种模式不会引起线程等待，因此也不会产生死锁：
package cn.net.bysoft.java.concurrency.design.ch03;
import java.util.concurrent.locks.ReentrantLock;
public class Example4 implements Runnable {
public static ReentrantLock lock1 = new ReentrantLock();
public static ReentrantLock lock2 = new ReentrantLock();
int lock;
public Example4(int lock) {
this.lock = lock;
}
public static void main(String[] args) {
Example4 r1 = new Example4(1);
Example4 r2 = new Example4(2);
Thread t1 = new Thread(r1);
Thread t2 = new Thread(r2);
t1.start();
t2.start();
}
@Override
public void run() {
if (lock == 1) {
while (true) {
if (lock1.tryLock()) {
try {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
}
if (lock2.tryLock()) {
try {
System.out.println(Thread.currentThread().getId() + ": My Job done");
return;
} finally {
lock2.unlock();
}
}
} finally {
lock1.unlock();
}
}
}
} else {
while (true) {
if (lock2.tryLock()) {
try {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
}
if (lock1.tryLock()) {
try {
System.out.println(Thread.currentThread().getId() + ": My Job done");
return;
} finally {
lock1.unlock();
}
}
} finally {
lock2.unlock();
}
}
}
}
}
}
上面的代码采用了非常容易死锁的加锁顺序，引发死锁。
但是使用tryLock()后，这种情况就大大改善了。只要执行足够长的时间，线程总会得到所有需要的资源，从而正常执行。
1.3 公平锁
在大多数情况下，锁的申请都是非公平的。而公平的锁，则不是这样，它会按照时间的先后顺序，保证先到先得，后到后得。公平锁的一大特点是：它不会产生饥饿现象。只要你排队，最终还是可以等到资源：
public ReentrantLock(boolean fair);
公平锁看似优美，但是要实现公平锁必然要系统维护一个有序队列，因此公平锁的实现成本比较高，性能相对也非常低下，因此，默认情况下，锁是非公平的。
package cn.net.bysoft.java.concurrency.design.ch03;
import java.util.concurrent.locks.ReentrantLock;
public class Example5 implements Runnable {
public static ReentrantLock fairLock = new ReentrantLock(true);
public static void main(String[] args) {
Example5 exp = new Example5();
Thread t1 = new Thread(exp, "t1");
Thread t2 = new Thread(exp, "t2");
t1.start();
t2.start();
}
@Override
public void run() {
while (true) {
try {
fairLock.lock();
System.out.println(Thread.currentThread().getName());
} finally {
fairLock.unlock();
}
}
}
}
对上面ReentrantLock的几个重要方法整理如下：
lock()：获得锁，如果锁已经被占用，则等待；lockInterruptibly()：获得锁，但优先响应中断；
tryLock()：尝试获得锁，如果成功，返回true，失败返回false。该方法不等待；
tryLock(long time, TimeUnit unit)：在给定时间内尝试获得锁；
unlock()：释放锁；
就重入锁的实现来看，主要集中在Java层面。包含三个要素：
原子状态；等待队列；
阻塞与恢复； 2. Condition条件
Condition与重入锁是相关联的，通过Lock接口的newCondition()方法可以生成一个与当前重入锁绑定的Condition实例。利用它，可以让线程在合适的时间等待，或者在某一个特定的时刻得到通知，继续执行。
Condition接口提供的基本方法如下：
void await() throws InterruptedException;
void awaitUninterruptibly();
long awaitNanos(long nanosTimeout) throws InterruptedException;
boolean await(long time, TimeUnit unit) throws InterruptedException;
boolean awaitUnitl(Date deadline) throws InterruptedException;
void signal();
void signalAll();
以上方法含义如下：
await()方法会使当前线程等待，同时释放当前锁，当其他线程中使用signal()或者signalAll()方法时，线程会重新获得锁继续执行。或者当线程被中断时，也能跳出等待；awaitUninterruptible()方法与await()方法基本相同，但是它并不会在等待过程中响应中断；
singal()方法用于唤醒一个在等待中的线程。相对的singalAll()方法会唤醒所有在等待中的线程；
下面的代码简单演示了Condition的功能：
package cn.net.bysoft.java.concurrency.design.ch03;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class Example6 implements Runnable {
public static ReentrantLock lock = new ReentrantLock();
public static Condition condition = lock.newCondition();
public static void main(String[] args) throws InterruptedException {
Example6 exp = new Example6();
Thread t1 = new Thread(exp);
t1.start();
Thread.sleep(2000);
lock.lock();
condition.signal();
lock.unlock();
}
@Override
public void run() {
try {
lock.lock();
condition.await();
System.out.println("Thread is going on");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
当线程使用Condition.await()时，要求线程持有相关的重入锁，在await()调用后，这个线程会释放这把锁，同理，在Condition.signal()方法调用时，也要求线程先获得相关的锁。在调用signal()方法后，一般需要释放相关的锁，谦让给被唤醒的线程，让它可以继续执行。
3. 信号量
信号量为多线程协作提供了更为强大的控制方法。广义上说，信号量是对锁的扩展。无论是内部锁synchronzied还是重入锁ReentrantLock，一次都只允许一个线程访问一个资源，而信号量却可以指定多个线程，同时访问某一个资源。信号量主要提供了一下构造函数：
public Semaphore(int permits)
public Semaphore(int permits, boolean fair)
信号量的主要逻辑方法有：
public void acquire();
public void acquireUninterruptibly();
public boolean tryAcquire();
public boolean tryAcquire(long timeout, TimeUnit unit);
public void release();
acquire()方法尝试获得一个准入的许可。若无法获得，则线程会等待，直到有线程释放一个许可或当前线程被中断。acquireUninterruptibly()方法和acquire()方法类似，但是不影响中断。tryAcquire()尝试获得一个许可，如果成功返回true，失败则返回false，它不会进行等待，例子返回。release()用于在线程访问资源结束后，释放一个许可，以使其他等待许可的线程可以进行资源访问：
package cn.net.bysoft.java.concurrency.design.ch03;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
public class Example7 implements Runnable {
final Semaphore semp = new Semaphore(5);
public static void main(String[] args) {
ExecutorService exec = Executors.newFixedThreadPool(20);
final Example7 exp = new Example7();
for (int i = 0; i < 20; i++) {
exec.submit(exp);
}
}
@Override
public void run() {
try {
semp.acquire();
Thread.sleep(2000);
System.out.println(Thread.currentThread().getId() + ": done!");
semp.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
这里声明了一个包含5个许可的信号量。这意味着同时可以有5个线程进入代码段。申请信号量使用acquire()操作，在离开时，务必使用release()释放信号量。
4. ReadWriteLock读写锁
读写分离锁可以有效地帮助减少锁竞争，以提升系统性能。用锁分离的机制来提升性能非常容易理解，必须线程A1，A2，A3进行写操作，B1，B2，B3进行读操作，如果使用重入锁或者内部锁，则理论上说所有读之间、读与写之间、写和写之间都是串行操作。
读
写
读
非阻塞
阻塞
写
阻塞
阻塞
读-读不互斥；
读-写互斥；
写-写互斥；
如果在系统中，读操作次数远远大于写操作，则读写锁就可以发挥最大的功效：
package cn.net.bysoft.java.concurrency.design.ch03;
import java.util.Random;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class Example8 {
private static ReentrantLock lock = new ReentrantLock();
private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
private static Lock readLock = readWriteLock.readLock();
private static Lock writeLock = readWriteLock.readLock();
private int value;
public Object handleRead(Lock lock) throws InterruptedException {
try {
lock.lock();
Thread.sleep(1000);
return value;
} finally {
lock.unlock();
}
}
public void handleWrite(Lock lock, int index) throws InterruptedException {
try {
lock.lock();
Thread.sleep(1000);
value = index;
} finally {
lock.unlock();
}
}
public static void main(String[] args) {
final Example8 exp = new Example8();
Runnable readRunnable = new Runnable() {
@Override
public void run() {
try {
exp.handleRead(readLock);
// exp.handleRead(lock);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
Runnable writeRunnable = new Runnable() {
@Override
public void run() {
try {
exp.handleWrite(writeLock, new Random().nextInt());
// exp.handleWrite(lock, new Random().nextInt());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
for (int i = 0; i < 18; i++) {
new Thread(readRunnable).start();
}
for (int i = 18; i < 20; i++) {
new Thread(writeRunnable).start();
}
}
}
上面这段代码使用读写锁，程序大约两秒就可以运行完成，而使用注释中的重入锁，则需要20秒才可以运行完成。
5. 倒计时器
CountDownLatch是一个非常实用的多线程控制工具类。通常用来控制线程等待，它可以让某一个线程等待知道倒计时结束，再开始执行。
public CountDownLatch(int count)
构造函数接收一个整数作为参数，即当前这个计数器的计数个数。
package cn.net.bysoft.java.concurrency.design.ch03;
import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Example9 implements Runnable {
static final CountDownLatch end = new CountDownLatch(10);
static final Example9 exp = new Example9();
public static void main(String[] args) throws InterruptedException {
ExecutorService exec = Executors.newFixedThreadPool(10);
for (int i = 0; i < 10; i++) {
exec.submit(exp);
}
end.await();
System.out.println("fire!");
exec.shutdown();
}
@Override
public void run() {
try {
Thread.sleep(new Random().nextInt(10) * 1000);
System.out.println("check complete");
end.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
上面代码生成了一个计数器，量为10。表示需要有10个线程完成任务，等待在计数器上的线程才能继续执行。待10个任务全部完成后，主线程才能继续执行。
6. 循环栅栏
CyclicBarrirer是另外一种多线程控制使用工具。和CountDownLatch非常类似，它也可以实现线程间的计数等待，但功能更复杂且强大。
假设我们将计数器设置为10，那么凑齐第一批10个线程后，计数器就会归零，然后接着凑齐下一批10个线程，这就是循环栅栏的含义。
下面使用循环栅栏演示了司令命令士兵完成任务的场景：
package cn.net.bysoft.java.concurrency.design.ch03;
import java.util.Random;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class Example10 {
public static class Soldier implements Runnable {
private String soldier;
private final CyclicBarrier cyclic;
public Soldier(CyclicBarrier cyclic, String soldierName) {
this.cyclic = cyclic;
this.soldier = soldierName;
}
@Override
public void run() {
try {
cyclic.await();
doWork();
cyclic.await();
} catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
}
public void doWork() {
try {
Thread.sleep(Math.abs(new Random().nextInt() % 10000));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(soldier + "完成任务");
}
}
public static class BarrierRun implements Runnable {
boolean flag;
int N;
public BarrierRun(boolean flag, int N) {
this.flag = flag;
this.N = N;
}
@Override
public void run() {
if (flag) {
System.out.println("司令：[士兵" + N + "个，任务完成！]");
} else {
System.out.println("司令：[士兵" + N + "个，集合完毕！]");
flag = true;
}
}
}
public static void main(String[] args) {
final int N = 10;
Thread[] allSoldier = new Thread[N];
boolean flag = false;
CyclicBarrier cyclic = new CyclicBarrier(N, new BarrierRun(flag, N));
System.out.println("集合队伍！");
for (int i = 0; i < N; ++i) {
System.out.println("士兵" + i + "报道！");
allSoldier[i] = new Thread(new Soldier(cyclic, "士兵" + i));
allSoldier[i].start();
}
}
}
在计数器打到指标时，执行run方法()，每一个士兵线程会执行定义的run()方法。每一个士兵线程都会等待，直到所有的士兵集合完毕。集合完毕后，意味着CyclicBarrier的一次计数器完成，当再一次调用CyclicBarrier.await()时，会进行下一次计数。上面的程序打印结果如下：
集合队伍！
士兵0报道！
士兵1报道！
士兵2报道！
士兵3报道！
士兵4报道！
士兵5报道！
士兵6报道！
士兵7报道！
士兵8报道！
士兵9报道！
司令：[士兵10个，集合完毕！]
士兵3完成任务
士兵6完成任务
士兵2完成任务
士兵0完成任务
士兵8完成任务
士兵5完成任务
士兵4完成任务
士兵9完成任务
士兵1完成任务
士兵7完成任务
司令：[士兵10个，任务完成！]
7. 线程阻塞工具类
LockSupport是一个非常方便实用的线程阻塞工具，它可以在线程内任意位置让线程阻塞。和Thread.suspend()相比，它弥补了由于resume()在前发生，导致线程无法继续执行的情况。也不需要先获得某个对象的锁，也不会抛出InterruptedException异常。
LockSupport的静态方法park()可以阻塞当前线程，类似的还有parkNanos()、parkUnitl()等方法：
package cn.net.bysoft.java.concurrency.design.ch03;
import java.util.concurrent.locks.LockSupport;
public class Example11 {
public static Object u = new Object();
static ChangeObjectThread t1 = new ChangeObjectThread("t1");
static ChangeObjectThread t2 = new ChangeObjectThread("t2");
public static class ChangeObjectThread extends Thread {
public ChangeObjectThread(String name) {
super.setName(name);
}
@Override
public void run() {
synchronized (u) {
System.out.println("in " + getName());
LockSupport.park();
}
}
}
public static void main(String[] args) throws InterruptedException {
t1.start();
Thread.sleep(100);
t2.start();
LockSupport.unpark(t1);
LockSupport.unpark(t2);
t1.join();
t2.join();
}
}
LockSupport类使用类似信号量的机制。它为每一个线程准备了一个许可，如果许可可用，那么park()函数会立即返回。并且消费这个许可，如果许可不可用，就会阻塞。而unpark()则使得一个许可变为可用。
这个特点使得：即使unpark()操作发生在park()之前，它也可以使下一次的park()操作立即返回。这也就是上诉代码可顺利结束的主要原因。