本章主要介绍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();
}
}
}