ReentrantLock

介绍

ReentrantLock是JDK实现的一个类，是对synchronized 的升级，其作用也是为了实现线程同步。

区别

1. ReentrantLock 是一个类，synchronized 是一个关键字。
2. ReentrantLock 是 JDK 实现，synchronized 是 JVM 实现。
3. synchronized 可以自动释放锁，ReentrantLock 需要手动释放。
4. ReentrantLock 可实现公平锁。（公平锁代表按时间执行）
5. ReentrantLock 可重复上锁，上几个锁就要解几个锁。
6. ReentrantLock 可在等待锁时，中断线程。

优势

1. 手动释放操作更加灵活。
2. 可自由切换公平锁、非公平锁。
3. 一直获取不到锁可中断，不用一直等待。

实现

package com.southwind.demo;

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

public class Test3 {
	public static void main(String[] args) {
		Account3 account = new Account3();
		new Thread(()->{
			account.count();
		},"A").start();
		new Thread(()->{
			account.count();
		},"B").start();
	}
}

class Account3{
	private static int num;
	private ReentrantLock reentrantLock = new ReentrantLock(true);//true则说明是公平锁
	
	public void count() {
		//上锁,连上两把锁
		reentrantLock.lock();
		reentrantLock.lock();
		num++;
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+"是当前的第"+num+"位访客");
		//上两次，解锁需解锁两次
		reentrantLock.unlock();
		reentrantLock.unlock();
	}
}

lockinterruptibly

interrupt()方法

线程在sleep或wait,join，别的进程调用 interrupt（）方法，此线程会被唤醒并被要求处理InterruptedException。

若线程正在运行，调用interrupt（）方法不会收到提醒。但可通过标志，可以通过isInterrupted()查看状态，并进行处理。

需要注意的是，子线程虽调用了interrupt（）方法，但子线程仍会继续运行业务代码。若要进行业务逻辑判断，需调用isInterrupted（）方法判断线程状态，是否执行后续代码。

lockinterruptibly

线程已调用interrupt（）方法，再调用lockinterruptibly仍会被要求处理InterruptedException。

lockInterruptibly（）会响应中断，调用后线程中断，后续逻辑代码不再执行。

lock、tryLock、lockInterruptibly

lock -> 调用后一直阻塞到获得锁

tryLock -> 尝试是否能获得锁 会立即返回获取结果

lockInterruptibly -> 调用后一直阻塞到获得锁 但是接受中断信号

package com.southwind.demo;

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

public class Test {
    public static void main(String[] args) {
        TimeLock timeLock = new TimeLock();
        /**
         * A 拿到锁，执行业务代码，休眠 5 秒钟
         * B 尝试拿锁，需要在 3 秒钟之内拿到锁
         */
        new Thread(()->{
            timeLock.lock();
        },"A").start();
        new Thread(()->{
            timeLock.lock();
        },"B").start();
    }
}

class TimeLock{

    private ReentrantLock reentrantLock = new ReentrantLock();

    public void lock(){
        /**
         * 尝试在3S内获取锁
         */
        try {
            if(reentrantLock.tryLock(3, TimeUnit.SECONDS)){
                System.out.println(Thread.currentThread().getName()+" get lock");
                TimeUnit.SECONDS.sleep(5);
            }else{
                System.out.println(Thread.currentThread().getName()+" not lock");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if(reentrantLock.isHeldByCurrentThread()){
                reentrantLock.unlock();
            }
        }
    }
}