【JUC基础】04. Lock锁
1、前言
java.util.concurrent.locks为锁定和等待条件提供一个框架的接口和类，说白了就是锁所在的包。
2、什么是Lock
Lock是一种锁机制，比同步块（synchronized block）更加灵活，同时也更加复杂的线程同步机制。在JDK1.5就已存在Lock接口了。
其中有三个实现类：
- ReentrantLock：可重入锁
- ReentrantReadWriteLock.ReadLock：读锁
- ReentrantReadWriteLock.WriteLock：写锁
3、Lock的API
Lock接口只提供了6个方法：
其中lock()和unlock()是配对的。lock()是加锁，而unlock()是解锁。lockInterruptibly()与lock()类似，区别在于lock()如果无法获取到锁，线程一直被阻塞，直到锁释放。而lockInterruptibly()允许线程被中断，并抛出java.lang.InterruptedException。
tryLock()只有在调用时才可以获得锁。如果可用，则获取锁定，并返回true，反之返回false。相应的还有重载方法tryLock(long time, TimeUnit unit)表示在给定的等待时间内空闲，则可以获取锁。如果到了超时时间，还没获取到就放弃获取。
4、ReentrantLock的基本使用
Lock是一个接口，官方文档其实也给了如何使用的说明：
- 声明Lock对象。Lock lock = new XXXLock();
- 方法执行加锁lock.lock();
- 在方法块执行完毕后，需要释放锁：lock.unlock();
由于LocK是一个接口，需要使用具体的实现。典型的实现如ReentrantLock。示例代码如下：
public class ReentrantLockDemo {
public static void main(String[] args) {
Phones phones = new Phones();
new Thread(() -> {
for(int i = 0; i< 50; i++) {
phones.sale();
}
}, "销售员小王").start();
new Thread(() -> {
for(int i = 0; i< 50; i++) {
phones.sale();
}
}, "销售员小红").start();
}
}
class Phones {
// 库存10部手机
private int total = 50;
// 1、 声明锁的实例
ReentrantLock lock = new ReentrantLock();
public void sale(){
try {
// 2、加锁，代码规约检测会提示你加载try的第一行
lock.lock();
if(total > 0){
System.out.println(Thread.currentThread().getName() + "卖出了一部手机，当前库存剩余：" + (--total));
}
} finally {
// 3、释放锁
lock.unlock();
}
}
}执行结果：
ReentrantLock是个可重入锁，其中可以执行公平锁和非公平锁。如new ReentrantLock(true)，默认是非公平锁（false）。
4.1、公平锁和非公平锁
- 公平锁：每个线程获取锁的顺序按照先后顺序获取。关键字眼：先到先得。
- 优点：能保证所有的线程都得到资源，不会产生线程饥饿现象。
- 缺点：吞吐量低，除了第一个线程以外，其余的都处于排队阻塞的状态，cpu需要每次唤醒线程，开销较大。
- 非公平锁：多个线程同时尝试获取，哪个线程优先获取到锁取决于系统分配策略。关键字眼：无需排队。
- 优点：吞吐量高，cpu无需唤醒所有的线程，开销低。
-
- 缺点：会产生线程饥饿现象，可能后到的线程先获取到锁，而前面的线程永远都获取不到
5、读写锁ReadWriteLock
ReadWriteLock是一个读写锁接口。什么是读写锁呢？看下官方文档说明：
ReadWriteLock分为一个读锁和一个写锁。读锁可以被多个线程持有，而写锁只能被一个线程持有。典型的实现类有ReentrantReadWriteLock。
读锁：就是我们常说的共享锁。
写锁：就是常说的独占锁。
示例代码：
public class ReadWriteLock {
public static void main(String[] args) {
MyMap map = new MyMap();
// 写操作
for (int i = 0; i < 5; i++) {
int finalI = i;
new Thread(() -> map.put(String.valueOf(finalI), String.valueOf(finalI))).start();
}
// 读操作
for (int i = 0; i < 5; i++) {
int finalI = i;
new Thread(() -> map.get(String.valueOf(finalI))).start();
}
}
}
// 模拟公共资源类
class MyMap extends HashMap<String, String> {
@Override
public String get(Object key) {
System.out.println(Thread.currentThread().getName() + "获取key:" + key);
return super.get(key);
}
@Override
public String put(String key, String value) {
System.out.println(Thread.currentThread().getName() + "写入key:" + key);
String put = super.put(key, value);
System.out.println(Thread.currentThread().getName() + "写入key:" + key + "完成");
return put;
}
}如果不加入任何的锁限制，我们直到结果肯定是很随机的。在写入操作时会被其他读线程插队。
加入读写锁后：
public class ReadWriteLock {
public static void main(String[] args) {
MyMap map = new MyMap();
// 写操作
for (int i = 0; i < 5; i++) {
int finalI = i;
new Thread(() -> map.put(String.valueOf(finalI), String.valueOf(finalI))).start();
}
// 读操作
for (int i = 0; i < 5; i++) {
int finalI = i;
new Thread(() -> map.get(String.valueOf(finalI))).start();
}
}
}
// 模拟公共资源类
class MyMap extends HashMap<String, String> {
private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
@Override
public String get(Object key) {
try{
rwLock.readLock().lock();
System.out.println(Thread.currentThread().getName() + "获取key:" + key);
return super.get(key);
} finally {
rwLock.readLock().unlock();
}
}
@Override
public String put(String key, String value) {
try {
rwLock.writeLock().lock();
System.out.println(Thread.currentThread().getName() + "写入key:" + key);
String put = super.put(key, value);
System.out.println(Thread.currentThread().getName() + "写入key:" + key + "完成");
return put;
} finally {
rwLock.writeLock().unlock();
}
}
}
我们可以看到在写入的时候，并不会有读的线程插队操作。
6、小结
关于Lock锁大概就讲这些，主要讲了ReentrantLock和ReadWriteLock的基本使用，也是通常比较常用的。其中Locks中还有一个接口Condition，这个等后面讲生产者和消费者的时候在细说。