文章目录：
写在前面
说说synchronized和Lock的区别？
Demo1（先演示一下锁的可重入性）
Demo2（ReentrantLock的基本使用）
Demo3（使用Lock锁同步不同方法中的代码块）
Demo4（ReentrantLock锁的可重入性）
Demo5（ReentrantLock的lockInterruptibly()方法）
Demo6（lockInterruptibly()方法可以避免死锁）
Demo7（ReentrantLock的tryLock(long time, TimeUnit unit)方法）
Demo8（ReentrantLock的tryLock()方法）
Demo9（tryLock()方法可以避免死锁）
写在前面
在 JDK5 中 增 加 了 Lock 锁 接 口，有 ReentrantLock 实 现类，ReentrantLock 锁称为可重入锁，它功能比 synchronized 多。
一般来说，我们称 synchronized 为内部锁，称 Lock 为显示锁。
说说synchronized和Lock的区别？
- synchronized是关键字，Lock是接口。
- synchronized无法获取锁的状态，Lock可以。
- synchronized会自动释放锁，Lock需要手动。
- synchronized没有Lock锁灵活（Lock锁可以自己定制）。
Demo1（先演示一下锁的可重入性）
package com.szh.lock;
/**
* 演示锁的可重入性
*/
public class Test01 {
public synchronized void metthod1() {
System.out.println("同步方法1");
//线程执行 metthod1() 方法,默认 this 作为锁对象,
//在 metthod1() 方法中调用了 method2() 方法,注意当前线程还是持有 this 锁对象的
//method2() 同步方法默认的锁对象也是 this 对象, 要执行 method2() 必须先获得 this 锁对象,
//当前 this 对象被当前线程持有,可以 再次获得 this 对象, 这就是锁的可重入性.
//假设锁不可重入的话,可能会造成死锁
method2();
}
public synchronized void method2() {
System.out.println("同步方法2");
method3();
}
public synchronized void method3() {
System.out.println("同步方法3");
}
public static void main(String[] args) {
Test01 obj=new Test01();
new Thread(new Runnable() {
@Override
public void run() {
obj.metthod1();
}
}).start();
}
}
Demo2（ReentrantLock的基本使用）
首先呢，Lock是JDK5中新增的锁接口，它的实现类中有一个常用的就是ReentrantLock，在这其中，先介绍一下 lock()、unlock() 方法，第一个是先获得锁，第二个是释放锁，而在这两个方法之间的代码就可以看作同步代码块。就像之前的synchronized。
package com.szh.lock;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* ReentrantLock 的基本使用
*/
public class Test02 {
//定义一个显示锁
static Lock lock=new ReentrantLock();
public static void method() {
//先获得锁
lock.lock();
//for循环此时就是同步代码块
for (int i = 0; i < 3; i++) {
System.out.println(Thread.currentThread().getName() + " ---> " + i);
}
//释放锁
lock.unlock();
}
public static void main(String[] args) {
Runnable r=new Runnable() {
@Override
public void run() {
method();
}
};
//启动三个线程
new Thread(r).start();
new Thread(r).start();
new Thread(r).start();
}
}可以看到，这里Thread-0线程先执行，经过lock.lock()获得了锁对象之后，执行for循环（此处相当于同步代码块），而在这个时候，Thread-1和Thread-2是无法进来执行for循环的，因为当前的锁对象是被Thread-0占有的，如果后两个子线程想要进来执行了话，必须等到Thread-0通过lock.unlock()方法释放锁对象之后，才可以执行。
Demo3（使用Lock锁同步不同方法中的代码块）
package com.szh.lock;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 使用 Lock 锁同步不同方法中的同步代码块
*/
public class Test03 {
//定义锁对象
static Lock lock=new ReentrantLock();
public static void method1() {
//经常在 try 代码块中获得 Lock 锁, 在 finally 子句中释放锁
try {
lock.lock(); //获得锁
System.out.println(Thread.currentThread().getName() + " ---method1--- " + System.currentTimeMillis());
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + " ---method1--- " + System.currentTimeMillis());
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock(); //释放锁
}
}
public static void method2() {
//经常在 try 代码块中获得 Lock 锁, 在 finally 子句中释放锁
try {
lock.lock(); //获得锁
System.out.println(Thread.currentThread().getName() + " ---method2--- " + System.currentTimeMillis());
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + " ---method2--- " + System.currentTimeMillis());
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock(); //释放锁
}
}
public static void main(String[] args) {
Runnable r1=new Runnable() {
@Override
public void run() {
method1();
}
};
Runnable r2=new Runnable() {
@Override
public void run() {
method2();
}
};
new Thread(r1).start();
new Thread(r1).start();
new Thread(r2).start();
new Thread(r2).start();
}
}这里的执行结果：首先创建了4个子线程，Thread-0先抢到CPU执行权，进来获得lock锁对象，中间有一个sleep方法，这个的意思是让当前执行它的线程进入睡眠状态，但是当前线程不会释放它占有的锁，所以其他三个子线程是进不来的，因为当前lock锁对象被Thread-0占有了，在Thread-0执行完毕后。其他三个子线程都是同样的道理，只是说每次运行的结果可能会不相同，是因为线程的执行是抢着执行的。
Demo4（ReentrantLock锁的可重入性）
package com.szh.lock;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* ReentrantLock 锁的可重入性
*/
public class Test04 {
static class SubThread extends Thread {
//定义锁对象
private static Lock lock=new ReentrantLock();
//定义变量
private static int num=0;
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
try {
//可重入锁指可以反复获得该锁
lock.lock();
lock.lock();
num++;
}finally {
lock.unlock();
lock.unlock();
}
}
}
}
public static void main(String[] args) throws InterruptedException {
SubThread t1=new SubThread();
SubThread t2=new SubThread();
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(SubThread.num);
}
}这个代码案例的意思：创建两个子线程，第一个子线程抢到了CPU执行权，开始执行，第一个lock.lock()获得了锁对象，之后还可以再次lock.lock()第二次获得该锁对象，这是完全可以的，也就是说Lock接口的实现类ReentrantLock是支持锁的可重入性的。但是释放锁的时候，你线程获得了几个锁对象，这里就需要释放几次锁对象。
如果说第一个子线程连续执行两次lock.lock()获得了两次锁对象，但是只执行一次lock.unlock()了话，就会出现一种结果：程序卡在这里了，因为第一个子线程申请了两个当前锁对象，只释放了一次当前锁对象，那么还有一个锁对象被它占有着，这就导致第二个子线程没法执行了，因为第一个子线程没有释放完锁对象，那么第二个子线程获得不到当前lock锁对象，就没法继续执行下去了，所以，程序卡在这里了。
Demo5（ReentrantLock的lockInterruptibly()方法）
package com.szh.lock;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* lockInterruptibly()方法
* 如果当前线程未被中断则获得锁,
* 如果当前线程被中断则出现异常.
*/
public class Test05 {
static class Service {
private Lock lock=new ReentrantLock(); //定义锁对象
public void serviceMethod() {
try {
//lock.lock(); 获得锁, 即使调用了线程的 interrupt() 方法, 也没有真正的中断线程
//如果线程被中断了, 不会获得锁, 会产生异常
lock.lockInterruptibly();
System.out.println(Thread.currentThread().getName() + " --- begin lock");
//执行一段耗时的操作
for (int i = 0; i < Integer.MAX_VALUE; i++) {
new StringBuilder();
}
System.out.println(Thread.currentThread().getName() + " --- end lock");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
System.out.println(Thread.currentThread().getName() + " === 释放锁");
lock.unlock(); //释放锁
}
}
}
public static void main(String[] args) throws InterruptedException {
Service s=new Service();
Runnable r=new Runnable() {
@Override
public void run() {
s.serviceMethod();
}
};
Thread t1=new Thread(r);
t1.start();
Thread.sleep(50);
Thread t2=new Thread(r);
t2.start();
Thread.sleep(50);
t2.interrupt(); //中断 t2 线程
}
}lockInterruptibly() 方法的作用：如果当前线程未被中断则获得锁，如果当前线程被中断则出现异常。
当你使用lock()来获得锁的时候，即使你让一个线程执行interrupt方法中断它也没有用。如果想让线程能够被中断了话，需要使用 lockInterruptibly() 方法。
上述代码的执行过程：创建了两个子线程，第一个子线程lock.lockInterruptibly()获得了锁对象，去执行同步代码块（for循环）了，因为start方法只要一给当前线程开辟出栈空间，那么它就结束了，开辟成功的线程就去执行自己的run方法了，而程序代码就可以正常向下执行了。所以这个时候第二个子线程也start了，它也会去执行run方法对应的要求，上来就是获得锁对象，而此时锁对象暂时被第一个子线程占有，而第一个子线程还在for循环那里呢（这个for循环很耗时的），这个时候main主线程中，已经走到了最后一行，中断第二个子线程，根据lock.lockInterruptibly()方法，如果执行它的线程被中断，则直接出现异常，所以第二个子线程会走catch子句，最后执行finally释放锁（当然了，它压根也就没获得锁，这里打印这句话是为了更好的理解），最后第一个子线程是可以顺利执行完、释放锁的。
Demo6（lockInterruptibly()方法可以避免死锁）
package com.szh.lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 通过 ReentrantLock 锁的 lockInterruptibly() 方法避免死锁的产生
*/
public class Test06 {
static class MyLock implements Runnable {
//创建两个ReentrantLock等锁对象
private static ReentrantLock lock1=new ReentrantLock();
private static ReentrantLock lock2=new ReentrantLock();
int lockNum; //定义整数变量,决定使用哪个锁,偶数用lock1,奇数用lock2
public MyLock(int lockNum) {
this.lockNum=lockNum;
}
@Override
public void run() {
try {
if (lockNum % 2 == 1) { //奇数, 先锁 1, 再锁 2
lock1.lockInterruptibly();
System.out.println(Thread.currentThread().getName() + "获得锁1，还需要获得锁2");
Thread.sleep(1000);
lock2.lockInterruptibly();
System.out.println(Thread.currentThread().getName() + "同时获得了锁1与锁2");
}else { //偶数, 先锁 2, 再锁 1
lock2.lockInterruptibly();
System.out.println(Thread.currentThread().getName() + "获得了锁2，还需要获得锁1");
Thread.sleep(1000);
lock1.lockInterruptibly();
System.out.println(Thread.currentThread().getName() + "同时获得了锁1与锁2");
}
}catch (InterruptedException e) {
e.printStackTrace();
}finally {
if (lock1.isHeldByCurrentThread()) { //判断当前线程是否持有该锁
lock1.unlock();
}
if (lock2.isHeldByCurrentThread()) {
lock2.unlock();
}
System.out.println(Thread.currentThread().getName() + "线程退出");
}
}
}
public static void main(String[] args) throws InterruptedException {
MyLock myLock1=new MyLock(11);
MyLock myLock2=new MyLock(22);
Thread t1=new Thread(myLock1);
Thread t2=new Thread(myLock2);
t1.start();
t2.start();
//在 main 线程, 等待 3000 ms, 如果还有线程没有结束就中断该线程
Thread.sleep(1000 * 3);
//可以中断任何一个线程来解决死锁, t2 线程会放弃对锁 1 的申请, 同时释放锁 2, t1 线程会完成它的任务
if (t2.isAlive()) {
t2.interrupt();
}
}
}首先创建两个子线程，同时创建两个锁对象，这两个子线程一人一个锁，分别执行自己的start方法，main主线程此时睡眠3秒。
第一个子线程执行run方法，首先获得锁1，然后sleep了1秒，让出CPU执行权，但不会释放锁；此时第二个子线程执行run方法，首先获得锁2，然后sleep了1秒；第一个子线程醒了，它还想获得锁2，锁2已被第二个子线程占有，无法获得；第二个子线程醒了，它还想获得锁1，锁1已被第一个子线程占有，无法获得；这个时候差不多main主线程也该醒了，它会判断当前的t2子线程是否还活着，如果活着，则中断t2子线程；根据lockInterruptibly()方法，如果被中断，则产生异常，所以此时第二个子线程会走catch子句，最后finally子句判断第二个子线程是否占有锁1、锁2，有就释放，最后第二个子线程执行完毕退出；最后剩了第一个子线程，因为锁2已经被第二个子线程释放了，所以它此时可以获得锁2了，那就顺利执行呗，到最后的finally子句，正常释放锁对象就可以了。
Demo7（ReentrantLock的tryLock(long time, TimeUnit unit)方法）
package com.szh.lock;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
/**
* tryLock(long time, TimeUnit unit) 的作用在给定等待时长内,
* 锁没有被另外的线程持有, 并且当前线程也没有被中断, 则获得该锁.
* 通过该方法可以实现锁对象的限时等待.
*/
public class Test07 {
static class TimeLock implements Runnable {
private static ReentrantLock lock=new ReentrantLock(); //定义锁对象
@Override
public void run() {
try {
//假设 t1 线程先持有锁, 完成任务需要 4 秒钟,
//这个时候 t2 线程尝试获得锁, t2 线程在 3 秒内还没有获得锁的话, 那么它就不再等了，直接放弃
if (lock.tryLock(3, TimeUnit.SECONDS)) {
System.out.println(Thread.currentThread().getName() + "获得锁，执行耗时任务");
Thread.sleep(1000 * 4);
/*
假设 t1 线程先持有锁, 完成任务需要 2 秒钟
这个时候t2 线程尝试获得锁, t2 线程会一直尝试
在它约定尝试的 3 秒内可以获得锁对象
*/
//Thread.sleep(1000 * 2);
}else {
System.out.println(Thread.currentThread().getName() + "没有获得锁");
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if (lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}
}
public static void main(String[] args) {
TimeLock timeLock=new TimeLock();
Thread t1=new Thread(timeLock);
Thread t2=new Thread(timeLock);
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
}
}ReentrantLock类中的tryLock(long time, TimeUnit unit)方法有两个参数，第一个参数是指定时间，第二个参数是时间的级别（它是一个枚举）。代码中的意思是时间是3、级别是SECONDS秒，所以就是3秒。
这里创建两个子线程，设置了它们各自的名称，之后分别start启动，当t1线程走到 lock.tryLock(3, TimeUnit.SECONDS) 时，会判断在3秒之内，如果这个锁没有被其他线程持有，而且t1线程也没有被中断，则获得该锁。那显然，此时lock锁对象无人持有，所以t1线程获得该锁，之后它睡眠了4秒；这个时候t2线程来了，它走到 lock.tryLock(3, TimeUnit.SECONDS) 时，也会像t1线程那样去判断3秒之内，如果这个锁没有被其他线程持有，而且t2线程也没有被中断，则获得该锁；显然该锁对象已经被t1线程持有了，而且t1线程还睡眠了4秒，也就是说t2线程等待3秒之后，t1线程还没有释放该锁对象，所以t2线程是获取不到这个锁对象的，所以t2线程就不会再等了，直接放弃，走else。
Demo8（ReentrantLock的tryLock()方法）
package com.szh.lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* tryLock() 当锁对象没有被其他线程持有的情况下, 才会获得该锁定
*/
public class Test08 {
static class Service {
private ReentrantLock lock=new ReentrantLock();
public void serviceMethod() {
try {
if (lock.tryLock()) {
System.out.println(Thread.currentThread().getName() + "获得锁定");
Thread.sleep(1000 * 3); //模拟执行任务的时长
}else {
System.out.println(Thread.currentThread().getName() + "没有获得锁定");
}
}catch (InterruptedException e) {
e.printStackTrace();
}finally {
if (lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}
}
public static void main(String[] args) throws InterruptedException {
Service service=new Service();
Runnable r=new Runnable() {
@Override
public void run() {
service.serviceMethod();
}
};
Thread t1=new Thread(r);
t1.start();
Thread.sleep(100);
Thread t2=new Thread(r);
t2.start();
}
}ReentrantLock类中的tryLock()方法，是对上面那个案例的一个方法重载，这个方法中没有参数。意思是说：当前线程申请该锁对象，如果该锁对象没有被其他线程持有，则获得该锁，同时返回true；否则返回false，不会进行等待。这个执行结果我就不再讲解了，很好理解的。
Demo9（tryLock()方法可以避免死锁）
package com.szh.lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 使用 tryLock() 可以避免死锁
*/
public class Test09 {
static class MyLock implements Runnable {
private static ReentrantLock lock1=new ReentrantLock();
private static ReentrantLock lock2=new ReentrantLock();
private int lockNum;
public MyLock(int lockNum) {
this.lockNum=lockNum;
}
@Override
public void run() {
if (lockNum % 2 == 0) { //偶数先锁 1, 再锁 2
while (true) {
try {
if (lock1.tryLock()) {
System.out.println(Thread.currentThread().getName() + "获得了锁1，还想获得锁2");
Thread.sleep(50);
try {
if (lock2.tryLock()) {
System.out.println(Thread.currentThread().getName() + "同时获得了锁1与锁2，完成任务了");
return;
}
} finally {
if (lock2.isHeldByCurrentThread()) {
lock2.unlock();
}
}
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if (lock1.isHeldByCurrentThread()) {
lock1.unlock();
}
}
}
}else { //奇数就先锁 2, 再锁 1
while (true) {
try {
if (lock2.tryLock()) {
System.out.println(Thread.currentThread().getName() + "获得了锁2，还想获得锁1");
Thread.sleep(50);
try {
if (lock1.tryLock()) {
System.out.println(Thread.currentThread().getName() + "同时获得了锁1与锁2，完成任务了");
return;
}
} finally {
if (lock1.isHeldByCurrentThread()) {
lock1.unlock();
}
}
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if (lock2.isHeldByCurrentThread()) {
lock2.unlock();
}
}
}
}
}
}
public static void main(String[] args) {
MyLock lock1=new MyLock(11);
MyLock lock2=new MyLock(22);
Thread t1=new Thread(lock1);
Thread t2=new Thread(lock2);
t1.start();
t2.start();
//运行后, 使用 tryLock() 尝试获得锁, 不会傻傻的等待, 通过循环不停的再次尝试, 如果等待的时间足够长, 线程总是会获得想要的资源
}
}
