可重入锁详解 synchronized和ReentrantLock

可重入锁详解

概述

什么是 “可重入”，可重入就是说某个线程已经获得某个锁，可以再次获取锁而不会出现死锁。例如

package com.test.abc;

// 演示可重入锁是什么意思，可重入，就是可以重复获取相同的锁，synchronized和ReentrantLock都是可重入的
// 可重入降低了编程复杂性
public class WhatReentrant {
	public static void main(String[] args) {
		new Thread(new Runnable() {
			@Override
			public void run() {
				synchronized (this) {
					System.out.println("第1次获取锁，这个锁是：" + this);
					int index = 1;
					while (true) {
						synchronized (this) {
							System.out.println("第" + (++index) + "次获取锁，这个锁是：" + this);
						}
						if (index == 10) {
							break;
						}
					}
				}
			}
		}).start();
	}
}

 

package com.test.abc;

import java.util.Random;
import java.util.concurrent.locks.ReentrantLock;

// 演示可重入锁是什么意思
public class WhatReentrant2 {
	public static void main(String[] args) {
		ReentrantLock lock = new ReentrantLock();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					lock.lock();
					System.out.println("第1次获取锁，这个锁是：" + lock);

					int index = 1;
					while (true) {
						try {
							lock.lock();
							System.out.println("第" + (++index) + "次获取锁，这个锁是：" + lock);
							
							try {
								Thread.sleep(new Random().nextInt(200));
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
							
							if (index == 10) {
								break;
							}
						} finally {
							lock.unlock();
						}

					}

				} finally {
					lock.unlock();
				}
			}
		}).start();
	}
}

在这个过程中并没有发生死锁

 

可重入锁有  synchronized 和 ReentrantLock

 

他们又有什么区别呢?

区别就是在我们使用 synchronized 的使用, 无需手动释放锁,  而当我们使用 ReentrantLock 的使用, 我们需要调用 ReentrantLock 的 unlock() 方法来释放锁;

 

下面我们来简单的分析一下  synchronized 和 ReentrantLock

（1）synchronized是独占锁，加锁和解锁的过程自动进行，易于操作，但不够灵活。ReentrantLock也是独占锁，加锁和解锁的过程需要手动进行，不易操作，但非常灵活。

（2）synchronized可重入，因为加锁和解锁自动进行，不必担心最后是否释放锁；ReentrantLock也可重入，但加锁和解锁需要手动进行，且次数需一样，否则其他线程无法获得锁。

（3）synchronized不可响应中断，一个线程获取不到锁就一直等着；ReentrantLock可以相应中断。

ReentrantLock好像比synchronized关键字没好太多，我们再去看看synchronized所没有的，一个最主要的就是ReentrantLock还可以实现公平锁机制。什么叫公平锁呢？也就是在锁上等待时间最长的线程将获得锁的使用权。通俗的理解就是谁排队时间最长谁先执行获取锁。

 

演示 ReentrantLock 公平锁

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

public class MyTest {

    //演示 ReentrantLock 实现公平锁

    private static ReentrantLock reentrantLock = new ReentrantLock(true);//true表示使用公平锁

    public static void main(String[] args) {
        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();
        new Thread(() ->test(),"线程F").start();
    }


    //test方法中循环执行了两次加锁和解锁的过程
    public static void test(){
        for(int i=0; i<2; i++){
            try {
                reentrantLock.lock();
                System.out.println(Thread.currentThread().getName()+"获取了锁");
                TimeUnit.SECONDS.sleep(2);
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                reentrantLock.unlock();//需手动释放锁
            }
        }
    }

}

控制台输出结果

线程A获取了锁
线程B获取了锁
线程C获取了锁
线程D获取了锁
线程E获取了锁
线程F获取了锁
线程A获取了锁
线程B获取了锁
线程C获取了锁
线程D获取了锁
线程E获取了锁
线程F获取了锁

 

 

演示 ReentrantLock 非公平锁

import java.util.concurrent.locks.ReentrantLock;

public class MyTest {

    //演示 ReentrantLock 实现非公平锁

    private static ReentrantLock reentrantLock = new ReentrantLock(false);//false表示使用非公平锁

    public static void main(String[] args) {
        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();
        new Thread(() ->test(),"线程F").start();
    }

    //test方法中循环执行了两次加锁和解锁的过程
    public static void test(){
        for(int i=0; i<2; i++){
            try {
                reentrantLock.lock();
                System.out.println(Thread.currentThread().getName()+"获取了锁");
                //TimeUnit.SECONDS.sleep(2);
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                reentrantLock.unlock();//需手动释放锁
            }
        }
    }

}

控制台输出结果

线程A获取了锁
线程A获取了锁
线程C获取了锁
线程C获取了锁
线程B获取了锁
线程B获取了锁
线程D获取了锁
线程D获取了锁
线程E获取了锁
线程E获取了锁
线程F获取了锁
线程F获取了锁

可见, 当我们在使用非公平锁时, 线程是随机获取到的锁的,谁运气好cpu时间片轮到哪个线程，哪个线程就能获取锁；

 

同时 ReentrantLock 还具有 响应中断 和 限时等待功能

响应中断就是一个线程获取不到锁，不会傻傻的一直等下去，ReentrantLock会给予一个中断回应。

限时等待通过 tryLock 方法来实现，可以选择传入时间参数，表示等待指定的时间，无参则表示立即返回锁申请的结果：true表示获取锁成功，false表示获取锁失败。我们可以将这种方法用来解决死锁问题。