【Java多线程】多线程同步——对“ReentrantLock”类的简单理解

写在前面： 这篇文章是java.util.concurrent（J.U.C）包中ReentrantLock锁(又叫重入锁)的学习笔记与总结。并不适合新手对于ReentrantLock的入门，所以：当你扫一下目录后并未发现自己熟悉的点，那么你应该放弃继续读本文；反之，你可以挑选你认为我写得好的点看看。希望你我都能共同进步！

---

在发生了多线程环境下各个线程的读写操作并不是安全的情形下，需要有解决线程安全的方案！可以看看前两篇文章：
【Java多线程】简单理解Java“多线程”机制
【Java多线程】多线程同步——对“synchronized”关键字的简单理解

Java 提供了两种锁机制来控制多个线程对共享资源的互斥访问：

• 第一个是 JVM 实现的 synchronized（内部锁），
• 而另一个是 JDK1.5 实现的 ReentrantLock（重入锁）。ReentrantLock 是 java.util.concurrent（J.U.C）包中的锁，名叫重入锁。

ReentrantLock类

先介绍一下ReentrantLock类的相关方法，如果你以前有了解过ReentrantLock类，现在绝对是你复习它、构建知识体系的好机会！😄😄

Lock接口的特性：

1. 自JDK1.5开始，替换synchronized，更加智能化的实现锁。
2. 而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使1. ck时需要在finally 块中释放锁，也即需要手动释放锁；
3. Lock 可以让等待锁的线程响应中断，而synchronized 却不行；
4. 通过Lock 可以知道有没有成功获取锁，而synchronized 却无法办到。

juc.locks.Lock接口：

1. void lock(); 获得这个锁，如果当前被另一个线程占用，则阻塞。

2. void unlock(); 释放这个锁。

3. void lockInterruptibly(); 在等待锁的过程中，可以响应中断。

4. Condition newCondition();

5. Boolean tryLock(); 如果一个线程迟迟得不到锁，那么它就会自动放弃对该锁的请求。

6. Boolean tryLock(long time, TimtUnit unit); 在time时间后都没有得到锁，就放弃放弃对该锁的请求。

ReentrantLock类特性：

1. 重入锁（Reentrant），拥有一个计数器（hold count）来跟踪对lock方法的嵌套调用。每调用一层嵌套，hold count加一，没出一层嵌套，hold count减一。
2. 重入锁的另一个特性：一个锁可以被一个线程连续获取多次。注意，如果获取多次，也一定要释放多次。

juc.locks.ReentrantLock类：（JDK1.5）

• public class ReentrantLock extends Object implements Lock,Serializable { }
• 是Lock接口的实现类；直接继承Object类

构造方法：

• ReentrantLock() 构造“重入锁”，保护临界区
• ReentrantLock(boolean fair) 如果fair等于true，则构造一个采用公平策略的锁，但速度慢！

第一个juc. Lock程序

使用Lock接口实现卖火车票

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

public class Main {
	public static void main(String[] args) {
		//创建Runnable接口实现类对象
		Tickets t = new Tickets();
		//创建3个Thread类对象,传递Runnable接口实现类
		Thread t0 = new Thread(t);
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);

		t0.start();
		t1.start();
		t2.start();
	}
}

class Tickets implements Runnable{
	private int ticket = 100;//定义出售的票源
	private Lock lock = new ReentrantLock();//在类的成员位置,创建Lock接口的实现类对象
	
	public void run(){
		while(true){
		    lock.lock();//调用Lock接口方法lock获取锁
			if( ticket > 0){//对票数判断,大于0,可以出售,变量--操作
				try{
				   Thread.sleep(10);
				   System.out.println(Thread.currentThread().getName()+" 出售第 "+ticket--);
				}catch(Exception ex){
					
				}finally{
					lock.unlock();//释放锁,调用Lock接口方法unlock
				}
			}
		}
	}
}

重入锁的特性

ReentrantLock特性一览：

1. 中断响应：方法void lockInterruptibly();实现。
2. 锁申请等待限时：方法Boolean tryLock();和Boolean tryLock(long time, TimtUnit unit);实现。
3. 公平锁：ReentrantLock类的构造方法实现。

参看：实战Java并发程序设计-葛一鸣P73

对比synchronized和ReentrantLock

两者都是可重入锁。

1. “可重入锁”概念是：自己可以再次获取自己的内部锁。
2. 比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。
3. 同一个线程每次获取锁，锁的计数器都自增1，所以要等到锁的计数器下降为0时才能释放锁。

synchronized 依赖于 JVM 而 ReentrantLock 依赖于 API

• synchronized 是依赖于 JVM 实现的，前面我们也讲到了 虚拟机团队在 JDK1.6 为 synchronized 关键字进行了很多优化，但是这些优化都是在虚拟机层面实现的，并没有直接暴露给我们。
• ReentrantLock 是 JDK 层面实现的（也就是 API 层面，需要 lock() 和 unlock() 方法配合 try/finally 语句块来完成），所以我们可以通过查看它的源代码，来看它是如何实现的。

ReentrantLock 比 synchronized 增加了一些高级功能
相比synchronized，ReentrantLock增加了一些高级功能。主要来说主要有三点：①等待可中断；②可实现公平锁；③可实现选择性通知（锁可以绑定多个条件）

---