java除了使用关键字synchronized外,还可以使用ReentrantLock实现独占锁的功能。而且ReentrantLock相比synchronized而言功能更加丰富,使用起来更为灵活,也更适合复杂的并发场景。这篇文章主要是从使用的角度来分析一下ReentrantLock
简介
ReentrantLock常常对比着synchronized来分析,我们先对比着来看然后再一点一点分析。
- synchronized是独占锁,加锁和解锁的过程都是自动进行,易于操作,但是不够灵活。ReentrantLock也是独占锁,加锁和解锁都需要手动进行,不易操作,但是非常灵活
- synchronized可冲入,因为加锁和解锁自动进行,不用担心是否释放锁;ReentrantLock可冲入,但是加锁和解锁需要手动进行,而且次数必须一样,否则其他线程无法获取锁
- synchronized不可以响应中断,一个线程获取不到锁就一直等着;ReentrantLock可以响应中断
ReentrantLock好像比synchronized关键字没好太多,我们再去看看synchronized所没有的,一个最主要的就是ReentrantLock还可以实现公平锁机制。什么叫公平锁呢?也就是在锁上等待时间最长的线程将获得锁的使用权。通俗的理解就是谁排队时间最长谁先执行获取锁。
使用
简单使用
我们先给出一个最基础的使用案例,也就是实现锁的功能。
public class testT {
private static final Lock lock = new ReentrantLock();
public static void main(String[] args) {
new Thread(()->test(), "线程A").start();
new Thread(()->test(), "线程B").start();
}
private static void test(){
try {
lock.lock();
System.out.println(Thread.currentThread().getName() + "获取了锁");
TimeUnit.SECONDS.sleep(2);
} catch (Exception e) {
e.printStackTrace();
} finally {
System.out.println(Thread.currentThread().getName() + "释放了锁");
lock.unlock();
}
}
}
在这里我们定义了一个ReentrantLock,然后再test方法中分别lock和unlock,运行一边就可以实现我们的功能。这就是最简单的功能实现,代码很简单。我们再看看ReentrantLock和synchronized不一样的地方,那就是公平锁的实现。
公平锁实现&&非公平锁【存疑】
对于公平锁的实现,就要结合我们的可重入性质了。公平锁的含义我们上面就已经说了,就是谁等的时间长,谁就先获取锁。
public class testT {
private static final Lock lock = new ReentrantLock(true);
public static void main(String[] args) {
for (int i = 0; i < 13; i++) {
new Thread(()->test(), "线程A").start();
new Thread(()->test(), "线程B").start();
new Thread(()->test(), "线程C").start();
new Thread(()->test(), "线程D").start();
new Thread(()->test(), "线程E").start();
}
}
private static void test(){
try {
lock.lock();
System.out.println(Thread.currentThread().getName() + "获取了锁");
TimeUnit.SECONDS.sleep(1);
} catch (Exception e) {
e.printStackTrace();
} finally {
//System.out.println(Thread.currentThread().getName() + "释放了锁");
lock.unlock();
}
}
}
首先new一个ReentrantLock的时候参数为true,表明实现公平锁机制。在这里我们多定义几个线程ABCDE。然后test方法中循环执行了两次加锁和解锁的过程
经实验发现,在java1.8中,,无论构造参数是true还是false,获取锁的顺序都不变
响应中断
响应中断就是一个线程获取不到锁,不会傻傻一直等下去,ReentrantLock会给一个中断回应。在这里我们举一个死锁的案例
public class testT {
private static final Lock lock = new ReentrantLock(true);
static class ThreadDemo implements Runnable {
Lock firstLock;
Lock secondLock;
public ThreadDemo(Lock firstLock, Lock secondLock) {
this.firstLock = firstLock;
this.secondLock = secondLock;
}
@Override
public void run() {
try {
firstLock.lockInterruptibly();
System.out.println(Thread.currentThread().getName() + "firstLock上锁");
TimeUnit.MICROSECONDS.sleep(50);
secondLock.lockInterruptibly();
System.out.println(Thread.currentThread().getName() + "secondLock上锁");
} catch (Exception e) {
e.printStackTrace();
} finally {
firstLock.unlock();
secondLock.unlock();
System.out.println(Thread.currentThread().getName() + "已经操作完了资源,正常结束");
}
}
}
static Lock lock1 = new ReentrantLock();
static Lock lock2 = new ReentrantLock();
public static void main(String[] args) {
Thread thread = new Thread(new ThreadDemo(lock1, lock2));
Thread thread1 = new Thread(new ThreadDemo(lock2, lock1));
thread.start();
thread1.start();
// 如果不加上下面这一句,会一直等
thread.interrupt(); // Thread-0中断,Thread-1就可以获取资源,然后正常运行了
}
}
限时等待
这个是什么意思呢?也就是通过我们的tryLock方法来实现,可以选择传入时间参数,表示等待指定的时间,无参则表示立即返回锁申请的结果:true表示获取锁成功,false表示获取锁失败。我们可以将这种方法用来解决死锁问题。
首先还是测试代码,不过在这里我们不需要再去中断其中的线程了,我们直接看线程类是如何实现的。
就这样一直不停的调试,一直等到获取到相应的资源为止。
当然,我们可以设置tryLock的超时等待时间tryLock(long timeout,TimeUnit unit),也就是说一个线程在指定的时间内没有获取锁,那就会返回false,就可以再去做其他事了。
OK,到这里我们就把ReentrantLock常见的方法说明了,所以其原理,还是主要通过源码来解释。而且分析起来还需要集合AQS和CAS机制来分析。我也会在下一篇文章来分析。感谢大家的持续关注和支持。
public class testT {
private static final Lock lock = new ReentrantLock(true);
static class ThreadDemo implements Runnable {
Lock firstLock;
Lock secondLock;
public ThreadDemo(Lock firstLock, Lock secondLock) {
this.firstLock = firstLock;
this.secondLock = secondLock;
}
@Override
public void run() {
try {
if (!firstLock.tryLock()){
TimeUnit.MICROSECONDS.sleep(10);
}
System.out.println(Thread.currentThread().getName() + "firstLock上锁");
TimeUnit.MICROSECONDS.sleep(50);
if (!secondLock.tryLock()){
TimeUnit.MICROSECONDS.sleep(10);
}
System.out.println(Thread.currentThread().getName() + "secondLock上锁");
} catch (Exception e) {
e.printStackTrace();
} finally {
firstLock.unlock();
secondLock.unlock();
System.out.println(Thread.currentThread().getName() + "已经操作完了资源,正常结束");
}
}
}
static Lock lock1 = new ReentrantLock();
static Lock lock2 = new ReentrantLock();
public static void main(String[] args) {
Thread thread = new Thread(new ThreadDemo(lock1, lock2));
Thread thread1 = new Thread(new ThreadDemo(lock2, lock1));
thread.start();
thread1.start();
}
}
在这个案例中,一个线程获取lock1时候第一次失败,那就等10毫秒之后第二次获取,就这样一直不停的调试,一直等到获取到相应的资源为止。
当然,我们可以设置tryLock的超时等待时间tryLock(long timeout,TimeUnit unit),也就是说一个线程在指定的时间内没有获取锁,那就会返回false,就可以再去做其他事了。
OK,到这里我们就把ReentrantLock常见的方法说明了,所以其原理,还是主要通过源码来解释。而且分析起来还需要集合AQS和CAS机制来分析。我也会在下一篇文章来分析。感谢大家的持续关注和支持。