Java并发编程（五）锁的使用（下）

显式锁

上篇讲了使用synchronized关键字来定义锁，其实Java除了使用这个关键字外还可以使用Lock接口及其实现的子类来定义锁，ReentrantLock类是Lock接口的一个实现，Reentrant是“重入”的意思，因此这个锁也是支持重入的，这里就不再测试它的重入性了，感兴趣的同学可以自行测试。这种方式是Java在jdk1.5才引入进来的功能，它的功能比synchronized关键字更为强大，但也有一个缺点：使用起来比synchronized关键字更麻烦。使用Lock来实现value++，代码如下：

class Entity {
	public static int value = 0;
}
class IncreaseThread implements Runnable {
	private static Lock lock = new ReentrantLock();
	public void run() {
		for(int i=0; i <100000; i++){
			lock.lock();
			try {
				Entity.value++;
			}
			finally {
				lock.unlock();
			}
		}
	}
}
public class ReentrantLockTest {
	public static void main(String[] args) throws InterruptedException {
		ExecutorService exec = Executors.newCachedThreadPool();
		exec.execute(new IncreaseThread());
		exec.execute(new IncreaseThread());
		exec.shutdown();
		Thread.sleep(5000);
		System.out.println("Value = " + Entity.value);
	}
}

　　

运行5秒后输出如下结果：

Value = 200000

在定义lock时将其声明为static的，因此两个IncreaseThread对象可以共用一个lock对象；如果使用的不是同一个对象，尝试获取的就不是同一个锁了，也就不会互斥。代码执行到lock()方法时会检查锁是否被占用，如果没有被占用则直接获取锁并执行下面的代码，如果已经被占用了则阻塞当前线程，等待锁被其他线程释放。使用lock设置的临界区从调用lock()方法开始，到调用unlock()方法结束，本例在try块中定义要执行的代码，在finally块中调用unlock()方法是一种常用的方式，这样即使要执行的代码中抛出异常，也可以保证锁会被正常释放。

试图获取锁

tryLock方法给我们提供了两种尝试获取锁的方式，即根据是否获取到了锁来执行不同的策略，我们先介绍两个方法的功能。

tryLock()：试图获取锁，如果锁没有被占用则得到锁、返回true、继续执行下面的代码；如果锁被占用了则立即返回false（不会被阻塞）、继续执行下面的代码。

tryLock(long time, TimeUnit unit)：与tryLock()类似，这个方法可以指定等待锁的最长时间，在这段时间内当前线程会被阻塞。如果时间内获得了锁则返回true并提前结束阻塞，反之返回false。

具体代码如下：

class TryToGetLockThread implements Runnable {
	public void run() {
		boolean alreadyGetLock = TryLockTest.lock.tryLock();
		if(alreadyGetLock) {
			try {
				System.out.println("新线程：我拿到锁了");
				Thread.sleep(3000);//持有锁3秒
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			finally {
				System.out.println("新线程：我要释放锁了 ");
				TryLockTest.lock.unlock();
			}
		}
	}
}
public class TryLockTest {
	public static Lock lock = new ReentrantLock();
	public static void main(String[] args) throws InterruptedException {
		ExecutorService exec = Executors.newCachedThreadPool();
		exec.execute(new TryToGetLockThread());
		exec.shutdown();
		boolean alreadyGetLock = lock.tryLock(2, TimeUnit.SECONDS);
		if(alreadyGetLock) {
			try {
				System.out.println("主线程：我拿到锁了");
			}
			finally {
				TryLockTest.lock.unlock();
			}
		}
		else {
			System.out.println("主线程：没拿到锁,可以做点别的事情");
		}
	}
}

运行程序后，输出结果如下，其中第一条是立即输出的，第二句是两秒之后输出的，第三句是三秒后输出的：

新线程：我拿到锁了

主线程：没拿到锁,可以做点别的事情

新线程：我要释放锁了

本例中我们创建了一个新线程，新线程使用tryLock()方法先获得了锁，持有这个锁3秒钟。主线程使用tryLock(long time, TimeUnit unit)方法来试图获取锁，由于新线程持有锁3秒，因此主线程执行lock.tryLock(2, TimeUnit.SECONDS)等待两秒后就放弃了获取锁，返回false；如果主线程等待4秒，那么它就可以得到锁，从而得到不同的结果，感兴趣的同学可以自行测试。

锁的对象是谁

有的同学可能觉得这个锁对应的是这个锁的对象（lock），实际上不是的，这个锁没有对应的锁对象，因此synchronized关键字和显式锁之间不能产生互斥效果。

让我们做一个测试：

class LockTest {
	private static Lock lock = new ReentrantLock();
	public static void neverStopMethod() {
		lock.lock();
		try {
			while(true){}//Never stop
		}
		finally{
			lock.unlock();
		}
	}
	public static void getLockMethod() {
		synchronized(lock) {
			System.out.println("我得到了class锁");
		}
	}
}
class NeverStopThread implements Runnable {
	public void run() {
		LockTest.neverStopMethod();
	}
}
public class TryToGetSameLock {
	public static void main(String[] args) throws InterruptedException {
		ExecutorService exec = Executors.newCachedThreadPool();
		exec.execute(new NeverStopThread());
		exec.shutdown();
		Thread.sleep(100);//等待0.1秒，确保新建的线程已经获得了锁
		LockTest.getLockMethod();
	}
}

程序运行后，立即输出以下结果，并且程序始终没有退出

我得到了class锁

neverStopMethod()方法使用显式锁，getLockMethod()使用内置锁来获取lock对象的锁，我们通过线程池创建了一个调用neverStopMethod()方法的线程，主线程等待0.1秒后再通过getLockMethod()方法来获取锁。如果这两个锁是互斥的，getLockMethod()会一直等待新线程释放锁，但是很遗憾，它没有等待而是直接获取了锁。

锁的公平性

公平锁：按照访问锁的先后顺序排队，先到先得，这个很好理解。

非公平锁：当一个线程想获取锁时，先试图插队，如果刚好占用锁的线程释放了锁，下一个线程还没来得及拿锁，那么当前线程就可以直接获得锁；如果锁正在被其它线程占用，则排队，排队的时候就不能再试图获得锁了，只能等到前面所有线程都执行完才能获得锁。

synchronized关键字和默认情况下的ReentrantLock都是非公平锁。非公平锁比公平锁的性能更好，假设线程一是队列中的第一个，线程二是想要插队的线程，当占用锁的线程释放了锁时JVM有两种选择：

1.阻塞线程二，启动线程一。

2.线程一的状态维持不变继续阻塞，线程二的状态也维持不变继续运行。线程状态的切换是耗费时间的，因此方案二的性能更好。

ReentrantLock类默认的构造方法是非公平锁，如果需要设置为非公平锁，只需要调用ReentrantLock(boolean fair)方法指定即可。

总结

最后我们来盘点一下synchronized关键字和ReentrantLock类各自的优势：

synchronized关键字的优势：

使用简单，不用显示释放锁，编写代码更简洁；ReentrantLock类需要显示释放锁，unlock()方法要写在finally块中，否则会有死锁的风险。

ReentrantLock类的优势：

提供了更多的特性，比如设置锁的公平性，检查锁是否被占用等功能；synchronized关键字只能是公平锁，并且没有额外的特性。

一般来讲我们不需要额外功能的时候才会使用ReentrantLock类，否则都是使用synchronized关键字。

公众号：今日说码。关注我的公众号，可查看连载文章。遇到不理解的问题，直接在公众号留言即可。