ReenTrantLock单单字面意思就可以理解是可重入的锁,其实synchronized关键字所使用的锁也是可重入的,这方面区别不大。两者都是同一个线程每进入一次,锁的计数器都自增1,所以要等到锁的计数器下降为0时才能释放锁。
看一个例子:
本例中由于m1锁定this,只有m1执行完毕后,m2才能执行。这里是复习synchronized最原始的语义
package com.example.demo.test;
import java.util.concurrent.TimeUnit;
public class ReenTrantLock1 {
synchronized void m1(){
for(int i = 0;i < 10;i++){
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(i);
}
}
synchronized void m2(){
System.out.println("m2执行...");
}
public static void main(String[] args) {
ReenTrantLock1 r1 = new ReenTrantLock1();
new Thread(r1::m1).start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(r1::m2).start();
}
}
使用ReenTrantLock可以完成同样的功能,需要注意的是,必须要手动释放锁
使用synchronized锁定的话如果遇到异常,jvm会自动释放锁,但是lock必须手动释放锁,因此经常在finally中进行锁的释放。
如下:
package com.example.demo.test;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ReenTrantLock2 {
Lock lock = new ReentrantLock();
void m1(){
try {
lock.lock();
for(int i = 0;i < 10;i++){
TimeUnit.SECONDS.sleep(1);
System.out.println(i);
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
void m2(){
lock.lock();
System.out.println("m2执行...");
lock.unlock();
}
public static void main(String[] args) {
ReenTrantLock2 r2 = new ReenTrantLock2();
new Thread(r2::m1).start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(r2::m2).start();
}
}
ReenTrantLock区别与synchronized关键字的功能:
(1)使用ReenTrantLock可以进行”尝试锁定“tryLock,这样的话,线程在无法锁定对象或者在指定时间内无法锁定对象时,线程可以决定是否继续等待。
将m2()修改后,尝试锁定,如果未锁定不在等待
void m2(){
boolean locked = lock.tryLock();
if(locked){
System.out.println("m2执行...");
lock.unlock();
}else {
System.out.println("m2未拿到锁...");
}
}
void m2(){
boolean locked = false;
try {
lock.tryLock(5,TimeUnit.SECONDS);
System.out.println("尝试5s,如果拿不到锁,该干嘛干嘛");
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
if(locked) lock.unlock();
}
}
(2)ReenTrantLock在用lockInterruptibly()方法锁定的时候,调用线程的interrupt()方法,是可以打断正在等待的线程的。
package com.example.demo.test;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ReenTrantLock4 {
public static void main(String[] args) {
Lock lock = new ReentrantLock();
Thread t1 = new Thread(()->{
try {
lock.lock();
System.out.println("t1启动");
TimeUnit.SECONDS.sleep(Integer.MAX_VALUE);//基本睡死
System.out.println("t1结束");
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
});
t1.start();
Thread t2 = new Thread(()->{
boolean b = false;
try {
lock.lockInterruptibly();//可被打断的
System.out.println("t2启动");
b = true;
TimeUnit.SECONDS.sleep(5);
System.out.println("t2结束");
} catch (InterruptedException e) {
System.out.println("打断t2");
}finally {
if(b)lock.unlock();
}
});
t2.start();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
t2.interrupt();//打断线程t2的等待
}
}
(3) ReenTrantLock默认是非公平锁,可以指定为公平锁。而synchronized是非公平锁。所谓的公平锁就是先等待的线程先获得锁。
ReentrantLock reentrantLock = new ReentrantLock(true);//默认非公平锁,true为公平锁