使用线程锁（Lock）实现线程同步

任务描述

本关任务：使用Lock，实现对于某一块代码的互斥访问。

相关知识

上一关我们谈到了synchronized关键字，synchronized关键字主要用来同步代码，实现同步互斥访问，也就是在同一时刻只能有一个线程访问临界资源。从而解决线程的安全问题。

如果一个方法或者代码块被synchronized关键字修饰，当线程获取到该方法或代码块的锁，其他线程是不能继续访问该方法或代码块的。

而其他线程要能访问该方法或代码块，就必须要等待获取到锁的线程释放这个锁，而在这里释放锁只有两种情况：

1. 线程执行完代码块，自动释放锁；

2. 程序报错，jvm让线程自动释放锁。

可能会有一种情况，当一个线程获取到对象的锁，然后在执行过程中因为一些原因（等待IO，调用sleep方法）被阻塞了，这个时候锁还在被阻塞的线程手中，而其他线程这个时候除了等之外，没有任何办法，我们想一想这样子会有多影响程序的效率。

synchronized是Java提供的关键字，使用起来非常方便，不过在有些情况下，它是具有很多局限性的。

因此就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间或者能够响应中断），通过Lock就可以办到。

在比如，当多个线程操作同一个文件的时候，同时读写是会冲突的，同时写也是会冲突的，但是同时读是不会发生冲突的，而我们如果用synchronized来实现同步，就会出现一个问题：

如果多个线程都只是进行读操作，所以当一个线程在进行读操作时，其他线程只能等待无法进行读操作。

因此就需要一种机制来使得多个线程都只是进行读操作时，线程之间不会发生冲突，而通过Lock就可以办到。

总的来说Lock要比synchronized提供的功能更多，可定制化的程度也更高，Lock不是Java语言内置的，而是一个类。

Lock接口

我们来了解一下反复提到的Lock，首先我们来查看它的源码：

1. public interface Lock {
   void lock();
   void lockInterruptibly() throws InterruptedException;
   boolean tryLock();
   boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
   void unlock();
   Condition newCondition();
   }

可以发现Lock是一个接口，其中：lock()、tryLock()、tryLock(long time, TimeUnit unit)和lockInterruptibly()方法是用来获取锁的，unlock()方法是用来释放锁的。

首先lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。

由于在前面讲到如果采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。

一个使用Lock的例子：

1. Lock lock = ...;
   lock.lock();
   try{
   //处理任务
   }catch(Exception ex){
   
   }finally{
   lock.unlock(); //释放锁
   }

tryLock()顾名思义，是用来尝试获取锁的，并且该方法有返回值，表示获取成功与否，获取成功返回true，失败返回false，从方法可以发现，该方法如果没有获取到锁时不会继续等待的，而是会直接返回值。

tryLock()的重载方法tryLock(long time, TimeUnit unit)功能类似，只是这个方法会等待一段时间获取锁，如果过了等待时间还未获取到锁就会返回false，如果在等待时间之内拿到锁则返回true。

所以我们经常这样使用：

1. Lock lock = ...;
   if(lock.tryLock()) {
   try{
   //处理任务
   }catch(Exception ex){
   
   }finally{
   lock.unlock(); //释放锁
   }
   }else {
   //如果不能获取锁，则直接做其他事情
   }

lock()方法的正确使用

因为Lock是一个接口所以我们在编程时一般会使用它的实现类，ReentrantLock是Lock接口的一个实现类，意思是“可重入锁”，接下来我们通过一个例子来学习lock()方法的正确使用方式。

示例1：

1. public class Test {
   private ArrayList<Integer> arrayList = new ArrayList<Integer>();
   public static void main(String[] args) {
   final Test test = new Test();
   
   new Thread(){
   public void run() {
   test.insert(Thread.currentThread());
   };
   }.start();
   
   new Thread(){
   public void run() {
   test.insert(Thread.currentThread());
   };
   }.start();
   }
   
   public void insert(Thread thread) {
   Lock lock = new ReentrantLock(); //注意这个地方
   lock.lock();
   try {
   System.out.println(thread.getName()+"得到了锁");
   for(int i=0;i<5;i++) {
   arrayList.add(i);
   }
   } catch (Exception e) {
   // TODO: handle exception
   }finally {
   System.out.println(thread.getName()+"释放了锁");
   lock.unlock();
   }
   }
   }

输出：

Thread-1得到了锁

Thread-0得到了锁

Thread-0释放了锁

Thread-1释放了锁

结果可能出乎你的意料，不对呀，按道理应该是一个线程得到锁其他线程不能获取锁了的啊，为什么会这样呢？是因为insert()方法中lock变量是一个局部变量。THread-0和Thread-1获取到的是不同的锁，这样不会造成线程的等待。

那怎么才能利用lock()实现同步呢？相信你已经想到了，只要将Lock定义成全局变量就可以了。

public class Test {
private ArrayList<Integer> arrayList = new ArrayList<Integer>();
private Lock lock = new ReentrantLock(); //注意这个地方

public static void main(String[] args) {
final Test test = new Test();

new Thread(){
public void run() {
test.insert(Thread.currentThread());
};
}.start();

new Thread(){
public void run() {
test.insert(Thread.currentThread());
};
}.start();
}

public void insert(Thread thread) {
lock.lock();
try {
System.out.println(thread.getName()+"得到了锁");
for(int i=0;i<5;i++) {
arrayList.add(i);
}
} catch (Exception e) {
// TODO: handle exception
}finally {
System.out.println(thread.getName()+"释放了锁");
lock.unlock();
}
}
}

结果：

Thread-0得到了锁

Thread-0释放了锁

Thread-1得到了锁

Thread-1释放了锁

这样就是我们预期的结果了。

很多时候我们为了提高程序的效率不希望线程为了等待锁而一直阻塞，这个时候可以使用tryLock()可以达到目的。

示例，将之前的insert()方法修改成tryLock()实现：

1. public void insert(Thread thread) {
   if(lock.tryLock()) {
   try {
   System.out.println(thread.getName()+"得到了锁");
   for(int i=0;i<5;i++) {
   arrayList.add(i);
   }
   } catch (Exception e) {
   // TODO: handle exception
   }finally {
   System.out.println(thread.getName()+"释放了锁");
   lock.unlock();
   }
   } else {
   System.out.println(thread.getName()+"获取锁失败");
   }
   }

输出：

Thread-0得到了锁

Thread-1获取锁失败

Thread-0释放了锁

编程要求
请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充。

测试说明
使得程序输出如下结果（因为线程的执行顺序是随机的可能需要你评测多次）：

Thread-0得到了锁

1

2

3

4

5

Thread-0释放了锁

Thread-1得到了锁

6

7

8

9

10

Thread-1释放了锁

Thread-2得到了锁

11

12

13

14

15

Thread-2释放了锁

答案：

package step3;

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

public class Task {
	public static void main(String[] args) {
		final Insert insert = new Insert();
		Thread t1 = new Thread(new Runnable() {
			public void run() {
				insert.insert(Thread.currentThread());
			}
		});
		Thread t2 = new Thread(new Runnable() {
			public void run() {
				insert.insert(Thread.currentThread());
			}
		});
		Thread t3 = new Thread(new Runnable() {
			public void run() {
				insert.insert(Thread.currentThread());
			}
		});
		// 设置线程优先级
		t1.setPriority(Thread.MAX_PRIORITY);
		t2.setPriority(Thread.NORM_PRIORITY);
		t3.setPriority(Thread.MIN_PRIORITY);

		t1.start();
		t2.start();
		t3.start();

	}
}
class Insert {
	public static int num;
	// 在这里定义Lock
	 Lock lock = new ReentrantLock(); 
	public void insert(Thread thread) {
		/********* Begin *********/
		
			try{
				lock.lock();
				System.out.println(thread.getName()+"得到了锁");
				for (int i = 0; i < 5; i++) {
					num++;
					System.out.println(num);
				}
			}catch(Exception e){}
			finally{
				lock.unlock();
				System.out.println(thread.getName()+"释放了锁");
				
			}
		
	}
		/********* End *********/
}