浅谈synchronized关键字和ReenTrantLock可重入锁

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为公平锁