JUC并发编程（1）：Lock、Condition、ReadWriteLock
本章主要介绍JUC.Locks包下的三个接口：Lock（可重入锁）、Condition（监听器）、ReadWriteLock（读写锁）
一、回顾synchronized锁
1、同步方法
public synchronized void method(int args){
}
- synchronized方法控制对象访问，每个对象对应一把锁
- 每个synchronized方法必须调用改方法对象的锁才能执行，否则线程阻塞
- 方法一旦执行，就独占该锁，直到方法结束才返回锁
2、同步块
synchronized(Obj){
}
-
同步代码块锁的是对象，对某个对象的增删改查，只用锁对象
-
Obj称之为同步监视器，可以是任何对象
- 第一个线程访问，锁定同步监视器，执行其中的代码
- 第二个线程访问，发现同步监视器被锁定，无法访问（相当于钥匙被拿走）
- 第一个线程访问完毕，解除同步监视器（相当于还钥匙）
- 第三个线程访问，发现没有锁，可以访问
-
synchronize锁的缺陷：
- synchronized是java的一个关键字，是java语言的内置特性，由于synchronized是自动进行锁的释放的，所以只存在两种释放锁的情况：
- 获取了对应方法锁的对象执行完了该方法（代码块）
- 线程执行异常，JVM会让线程自动释放锁
此时就存在线程容易被阻塞问题（比如调用了sleep方法，sleep方法是抱着锁睡觉的！），其他线程只能干巴巴的等待。
此时就出现了JUC中的Lock锁，能够让我们区分读写的对线程进行操作。
二、Lock（重点）
Lock是一个锁接口，在JUC.locks包下。该包下还有另外两个接口：Condition（监视器，实现精准唤醒）、ReadWriteLock（读写锁）
-
接口方法
public interface Lock { //获取锁 void lock(); //获取锁，如果当前线程被中断，可以响应中断 void lockInterruptibly() throws InterruptedException; //尝试获取锁，返回布尔值 /** * Lock lock = ...; * if (lock.tryLock()) { * try { * // manipulate protected state * } finally { * lock.unlock(); * } * } else { * // perform alternative actions */ boolean tryLock(); //在给定时间内尝试获取锁。 boolean tryLock(long time, TimeUnit unit) throws InterruptedException; //释放锁 void unlock(); //获取监听器 Condition newCondition(); }
1、ReentrantLock（可重入锁）
ReentrantLock是Lock接口最具代表的一个实现类，有着和synchronized锁相似的功能，但是区别于synchronized是，它对锁有更强的可操控性，能够显示的获取锁，显示的释放锁。
- 无参构造函数默认为非公平锁（有参构造传入True可以为公平锁）
public ReentrantLock() {
sync = new NonfairSync();//默认非公平锁，可以插队
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
使用方法：
Lock lock = new ReentrantLock();//创建锁
lock.lock();//加锁
try {
//撰写业务代码
} finally {
lock.unlock();//解锁
}
2、synchronized和lock区别
-
synchronized是内置的java关键字，Lock是一个java类
-
synchronized无法判断锁的状态，Lock可以判断是否获得到了锁
-
synchronized会自动释放锁，lock必须手动释放锁，如果不释放则死锁
-
synchronized一个线程如果获得锁阻塞，则另外的线程傻傻等待，则lock不一定
-
synchronized可重入锁，不可以中断的，非公平的；Lock可重入锁，可以判断锁，非公平（可以自己设置）
-
synchronized适合锁的少量代码，lock适合大量锁的代码
三、Condition
Condition是一个监视器接口，在JUC.locks包下。是在JDK1.5出现用来替代传统Object()的wait()和notify()来实现线程中通信协作。相比传统的Object()的wait()和notify()，Condition下的await()和signal()更安全高效，所以我们一般推荐使用Condition。
1、JUC版本的生产者消费者模型：Lock-condition-await-signal
package com.yzc;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class TestPc {
public static void main(String[] args) {
Data data = new Data(); //创建业务类实例对象
new Thread(()->{
//开启生产者线程
for (int i = 0; i < 10; i++) {
try {
data.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
new Thread(()->{
//开启消费者线程
for (int i = 0; i < 10; i++) {
try {
data.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}
class Data{
private int number = 0;
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition(); //创建监听器
public void increment() throws InterruptedException {
lock.lock(); //加锁
try {
while(number!=0){
//如果无需生产
condition.await(); //则等待
}
number++; //否则生产并通知
System.out.println(Thread.currentThread().getName()+"---"+number);
condition.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public synchronized void decrement() throws InterruptedException {
lock.lock();
try {
while(number==0){
//如果无需消费
condition.await(); //则等待
}
number--; //否则消费，并通知
System.out.println(Thread.currentThread().getName()+"---"+number);
condition.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
2、Condition实现精准唤醒
class Date3{
//主要是业务类代码不同
private Lock lock = new ReentrantLock();
Condition condition1 = lock.newCondition(); //创建三个监听器，依次轮流唤醒线程
Condition condition2 = lock.newCondition();
Condition condition3 = lock.newCondition();
private int number = 1;
public void printA(){
lock.lock();
try {
while(number!=1){
condition1.await();
}
number=2;
System.out.println(Thread.currentThread().getName()+"A");
condition2.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printB(){
lock.lock();
try {
while(number!=2){
condition2.await();
}
number=3;
System.out.println(Thread.currentThread().getName()+"B");
condition3.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printC(){
lock.lock();
try {
while(number!=3){
condition3.await();
}
number=1;
System.out.println(Thread.currentThread().getName()+"C");
condition1.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
四、读写锁-ReadWriteLock
由于可重入锁ReentrantLock实现了标准的互斥锁，在一个线程获取了这个锁，其他线程想获取相同的锁时得保持等待状态，等待当前线程释放锁。一次最多只能有一个线程持有锁，这种情况可以很好的避免了写-写、读-写的线程安全问题，但是读-读的可用性重叠也同时被避开了，但是在大多数情况下，我们数据允许多个人同时访问时，此时ReentrantLock锁就不太适合，此时需要引入读写锁。
-
**独占锁：**一次只能被一个线程占用
-
**共享锁：**一次可以被多个线程占用
-
用法：
1. private ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); 2. readWriteLock.writeLock().lock(); readWriteLock.writeLock().unlock();//同lock锁相同用法 3. readWriteLock.readLock().lock(); readWriteLock.readLock().unlock(); -
业务类代码：以缓存为例子
class MyCacheLock{
private volatile Map<String,Object> map = new HashMap<>();
//读写锁：更加细粒度的控制
private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
//存，写入的时候，只希望同时只有一个线程写
public void put(String key,Object value){
readWriteLock.writeLock().lock();//修改缓存时候，只能一个一个操作，用读锁
try {
System.out.println(Thread.currentThread().getName()+"写入"+key);
map.put(key,value);
System.out.println(Thread.currentThread().getName()+"写入完毕");
} catch (Exception e) {
e.printStackTrace();
} finally {
readWriteLock.writeLock().unlock();
}
}
//取，取出的时候，所有人都可以读！
public void get(String key){
readWriteLock.readLock().lock();//查看缓存时候，可以同时读取。
try {
System.out.println(Thread.currentThread().getName()+"读取"+key);
Object o = map.get(key);
System.out.println(Thread.currentThread().getName()+"读取完毕");
} catch (Exception e) {
e.printStackTrace();
} finally {
readWriteLock.readLock().unlock();
}
}
}