ReentrantLock(可重入锁)
ReentrantLock了解吗?是公平锁吗?
ReentrantLock
(可重入锁) 实现了Lock接口,是一个可重入且独占式 的锁,和synchronized
关键字类似,不过ReentrantLock
更灵活、强大,增加了轮询、超时、中断、公平锁和非公平锁等高级功能。
重入锁指在同一线程中,外部方法获得锁之后,内层递归方法依然可以获得该锁,如果锁不具备重入性,那么当同一个线程两次获取锁的时候就会发生死锁。
独占锁指该锁在同一时刻只能被一个线程获取,而获取锁的其他线程只能在同步队列中等待。
ReentrantLock
默认使用非公平锁,也可以通过构造器显式指定公平锁。
- 公平锁:锁被释放之后,先申请的线程先得到锁。性能较差,公平锁为了保证时间上的绝对顺序,上下文切换更频繁。
- 非公平锁:锁被释放之后,后申请的线程可能会先获取到锁,是随机或者按照其他优先级排序的。性能更好,但可能会导致某些线程无法获取到锁。
synchronized与ReentrantLock的异同
-
两者都是可重入锁
-
synchronized
依赖于JVM
而ReentrantLock
依赖于API,synchronized
是依赖于JVM的,而ReentrantLock
是JDK层面实现的也就是API层面,需要lock()
和unlock()
方法配合try/finally
语句块来完成。 -
synchronized
不需要用户手动释放锁,ReentrantLock
则需要用户手动释放锁。 -
ReentrantLock
比synchronized
增加了一些高级功能:等待可中断 :
ReentrantLock
提供了一种能够中断等待锁的线程的机制,通过lock.lockInterruptibly()
来实现这个机制。也就是说正在等待的线程可以选择放弃等待,改为处理其他事情。可实现公平锁 :
ReentrantLock
可以指定是公平锁还是非公平锁。而synchronized
只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。ReentrantLock
默认情况是非公平的,可以通过ReentrantLock
类的ReentrantLock(boolean fair)
构造方法来指定是否是公平的。可实现选择性通知(锁可以绑定多个条件) :
synchronized
关键字与wait()
和notify()
/notifyAll()
方法相结合可以实现等待/通知机制。ReentrantLock
类当然也可以实现,但是需要借助于Condition
接口与newCondition()
方法。
ReentrantLock如何避免死锁:响应中断、可轮询锁、定时锁
(1)响应中断:在synchronized中如果有一个线程尝试获取一把锁,则其结果是要么获取锁继续执行,要么继续等待。ReentrantLock还提供了可响应中断的可能,即在等待锁的过程中,线程可以按需取消对锁的请求。
(2)可轮询锁:通过boolean tryLock()
获取锁。如果有可用锁,则获取该锁并返回true,如果无可用锁,则立即返回false。
(3)定时锁:通过boolean tryLock(long time,TimeUnit unit) throws InterruptedException
获取锁。如果在指定的时间内获取到了可用锁,且当前线程未被中断,则获取该锁并返回true。如果在指定的时间内获取不到可用锁,则将禁用当前线程,并且在发生如下三种情况之前,该线程一直处于休眠状态。
- 当前线程获取到了可用锁并返回true。
- 在当前线程进入此方法时若设置了该线程的中断状态,或者当前线程在获取锁时被中断,则将抛出
InterruptedException
,并清除当前线程的已中断状态。 - 当前线程获取锁的时间超过了指定的等待时间,将返回false。如果设定的时间小于或等于0,则该方法将完全不等待。
ReentrantLock抢占锁的三种方法
lock()
方法用于阻塞抢锁,抢不到锁时线程会一直阻塞。tryLock()
方法用于尝试抢锁,该方法有返回值,如果成功就返回true
,如果失败(锁已被其他线程获取)就返回false
。此方法无论如何都会立即返回,在抢不到锁时,线程不会像调用lock()
方法那样一直被阻塞。tryLock(long time,TimeUnit unit)
方法和tryLock()
方法类似,只不过这个方法在抢不到锁时会阻塞一段时间。如果在阻塞期间获取到锁就立即返回true
,超时则返回false
。
(1)使用lock()
方法
csharp
public void lock()
模板代码如下:
csharp
ReentrantLock lock = new ReentrantLock();
lock.lock(); //1:抢占锁
try {
//2:抢锁成功,执行临界区代码
} finally {
lock.unlock();//3:释放锁
}
注意:
-
释放锁操作
lock.unlock()
必须在try-catch
结构的finally
块中执行,否则,如果临界区代码抛出异常,锁就有可能永远得不到释放。 -
抢占锁操作
lock.lock()
必须在try语句块之外,而不是放在try语句块之内。原因一:
lock()
方法没有声明抛出异常,所以可以不包含到try块中。原因二:
lock()
方法并不一定能够抢占锁成功,如果没有抢占成功,当然也就不需要释放锁,而且在没有占有锁的情况下去释放锁,可能会导致运行时异常。 -
在抢占锁操作
lock.lock()
和try语句之间不要插入任何代码,避免抛出异常而导致释放锁操作lock.unlock()
执行不到,导致锁无法被释放。
(2)调用tryLock()
方法非阻塞抢锁
java
public boolean tryLock()
lock()
是阻塞式抢占,在没有抢到锁的情况下,当前线程会阻塞。
tryLock()
是非阻塞式抢占,在没有抢到锁的情况下,当前线程会立即返回,不会被阻塞。
csharp
//创建锁对象
ReentrantLock lock = new ReentrantLock();
if(lock.tryLock()){//1:尝试抢占锁
try {
//2:抢锁成功,执行临界区代码
} finally {
lock.unlock(); //3:释放锁
}
}else{
//4:抢锁失败,执行后备动作
}
(3)调用tryLock(long time,TimeUnit unit)
方法抢锁
java
public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException
tryLock(long timeout, TimeUnit unit) throws InterruptedException
方法用于限时抢锁,该方法在抢锁时会进行一段时间的阻塞等待,其中的time
参数代表最大的阻塞时长,unit
参数为时长的单位。
csharp
//创建锁对象
ReentrantLock lock = new ReentrantLock();
try {
if(lock.tryLock(1, TimeUnit.SECONDS)){//1:尝试抢占锁
try {
//2:抢锁成功,执行临界区代码
} finally {
lock.unlock(); //3:释放锁
}
}else{
//4:限时抢锁失败,执行后备动作
}
} catch (InterruptedException e) {
e.printStackTrace();
}
Condition
与Object对象的wait
、notify
两类方法类似,基于Lock显式锁,JUC也提供了一个用于线程间进行"等待-通知"方式实现的接口java.util.concurrent.locks.Condition
。
(1)Lock接口的主要方法
java
public interface Condition{
//方法1:等待,使当前线程加入等待队列中,并释放当前锁
//当其他线程调用signal()时,等待队列中的某个线程会被唤醒,重新去抢锁
void await() throws InterruptedException;
//方法2:通知。此方法在功能上与Object.notify()语义等效
//唤醒一个在await()等待队列中的线程
void signal();
//方法3:通知全部。唤醒await()等待队列中所有的线程,此方法与Object.notifyAll()语义上等效
void signalAll();
//方法3:限时等待。此方法与await()语义上等效
//不同点在于,在指定time等待超时后,如果没有被唤醒,线程将中止等待
//线程等待超时返回false,其他情况返回true
boolean await(long time, TimeUnit unit) throws InterruptedException
}
Condition
对象的signal
(通知)方法和同一个对象的await
(等待)方法是一一配对使用的,也就是说,一个Condition
对象的signal
(或signalAll
)方法不能去唤醒其他Condition
对象上的await
线程。
Condition
对象是基于显式锁的,所以不能独立创建一个Condition
对象,而是需要借助于显式锁实例去获取其绑定的Condition
对象。
不过,每一个Lock显式锁实例都可以有任意数量的Condition
对象。具体来说,可以通过lock.newCondition()
方法去获取一个与当前显式锁绑定的Condition
实例,然后通过该Condition
实例进行"等待-通知"方式的线程间通信。
csharp
public class ReentrantLockCondition {
//创建一个显式锁
static Lock lock=new ReentrantLock();
//获取一个显式锁绑定的Condition对象
static private Condition condition=lock.newCondition();
//等待线程执行异步目标任务
static class WaitTarget implements Runnable{
@Override
public void run() {
lock.lock();//1:抢占锁
try {
System.out.println("我是等待方");
condition.await();//2:开始等待,并且释放锁
System.out.println("收到通知,等待方继续执行");
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();//释放锁
}
}
}
//通知线程的异步目标任务
static class NotifyTarget implements Runnable{
@Override
public void run() {
lock.lock(); //3:抢锁
try {
System.out.println("我是通知方");
condition.signal(); //4:发送通知
System.out.println("发出通知了,但是线程还没有立马释放锁");
} finally {
lock.unlock(); //5:释放锁之后,等待线程才能获得锁
}
}
}
public static void main(String[] args) throws InterruptedException {
//创建等待线程
Thread waitThread = new Thread(new WaitTarget(), "WaitThread");
//启动等待线程
waitThread.start();
Thread.sleep(2000);//等待一会
//创建通知线程
Thread notifyThread = new Thread(new NotifyTarget(), "NotifyThread");
//启动通知线程
notifyThread.start();
}
}