持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第20天，点击查看活动详情

ReentrantLock 通过方法lock()与unlock()来进行加锁与解锁操作，与synchronized会被JVM自动解锁机制不同，ReentrantLock加锁后需要手动进行解锁；为了避免程序出现异常而无法正常解锁的情况，使用ReentrantLock必须在finally控制块中进行解锁操作。ReentrantLock 相比synchronized的优势是可中断、公平锁、多个锁，这种情况下需要使用 ReentrantLock。

一、Synchronized的实现原理

Synchronized进过编译，会在同步块的前后分别形成monitorenter和monitorexit这个两个字节码指令。在执行monitorenter指令时，首先要尝试获取对象锁。如果这个对象没被锁定，或者当前线程已经拥有了那个对象锁，把锁的计算器加1，相应的，在执行monitorexit指令时会将锁计算器就减1，当计算器为0时，锁就被释放了。如果获取对象锁失败，那当前线程就要阻塞，直到对象锁被另一个线程释放为止。

public class SynDemo{
	public static void main(String[] arg){
		Runnable t1=new MyThread();
		new Thread(t1,"t1").start();
		new Thread(t1,"t2").start();
	}
 
}
class MyThread implements Runnable {
	@Override
	public void run() {
            synchronized (this) {//加锁，系统自动解锁
		for(int i=0;i<10;i++)
                    System.out.println(Thread.currentThread().getName()+":"+i);
            }
		
	}
 
}

二、ReentrantLock实现原理

ReenTrantLock的实现是一种自旋锁，通过循环调用CAS操作来实现加锁。它的性能比较好也是因为避免了使线程进入内核态的阻塞状态。想尽办法避免线程进入内核的阻塞状态是我们去分析和理解锁设计的关键钥匙。

class MyThread implements Runnable {
	private Lock lock=new ReentrantLock();
	public void run() {
            lock.lock();//手动加锁
            try{
                for(int i=0;i<5;i++){
                    System.out.println(Thread.currentThread().getName()+":"+i);
                }
            }finally{
		lock.unlock();//手动解锁
            }
	}
}

由于ReentrantLock是java.util.concurrent包下提供的一套互斥锁，相比Synchronized，ReentrantLock类提供了一些高级功能，主要有以下3项：

1.等待可中断，持有锁的线程长期不释放的时候，正在等待的线程可以选择放弃等待，这相当于Synchronized来说可以避免出现死锁的情况。通过lock.lockInterruptibly()来实现这个机制。

2.公平锁，多个线程等待同一个锁时，必须按照申请锁的时间顺序获得锁，Synchronized锁非公平锁，ReentrantLock默认的构造函数是创建的非公平锁，可以通过参数true设为公平锁，但公平锁表现的性能不是很好。

公平锁、非公平锁的创建方式：

//创建一个非公平锁，默认是非公平锁
Lock lock = new ReentrantLock();
Lock lock = new ReentrantLock(false);
 
//创建一个公平锁，构造传参true
Lock lock = new ReentrantLock(true);

3.锁绑定多个条件，一个ReentrantLock对象可以同时绑定对个对象。ReenTrantLock提供了一个Condition（条件）类，用来实现分组唤醒需要唤醒的线程们，而不是像synchronized要么随机唤醒一个线程要么唤醒全部线程。

private Condition condition=lock.newCondition();//创建 Condition
public class MyService {
private Lock lock = new ReentrantLock();
//Lock lock=new ReentrantLock(true);//公平锁
//Lock lock=new ReentrantLock(false);//非公平锁
private Condition condition=lock.newCondition();//创建 Condition
public void testMethod() {
    try {
        lock.lock();//lock 加锁
        //1：wait 方法等待：
        //System.out.println("开始 wait");
        condition.await();
        //通过创建 Condition 对象来使线程 wait，必须先执行 lock.lock 方法获得锁
        //:2：signal 方法唤醒
        condition.signal();//condition 对象的 signal 方法可以唤醒 wait 线程
        for (int i = 0; i < 5; i++) {
            System.out.println("ThreadName=" + Thread.currentThread().getName()+ (" " + (i + 1)));
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }finally{
        lock.unlock();
    }
}

三、Condition 类和 Object 类锁方法区别

1. Condition 类的 awiat 方法和 Object 类的 wait 方法等效。
2. Condition 类的 signal 方法和 Object 类的 notify 方法等效。
3. Condition 类的 signalAll 方法和 Object 类的 notifyAll 方法等效。
4. ReentrantLock 类可以唤醒指定条件的线程，而 object 的唤醒是随机的。

四、tryLock和lock和lockInterruptibly的区别

1. tryLock能获得锁就返回true，不能就立即返回false，tryLock(long timeout,TimeUnit unit)，可以增加时间限制，如果超过该时间段还没获得锁，返回false。
2. lock能获得锁就返回true，不能的话一直等待获得锁。
3. lock 和 lockInterruptibly，如果两个线程分别执行这两个方法，但此时中断这两个线程，lock不会抛出异常，而lockInterruptibly会抛出异常。