并发编程demo记录demo20 ReentrantLock（可重入锁）系列

马士兵高并发编程系列记录

https://www.bilibili.com/video/av11076511/?spm_id_from=333.788.videocard.4

ReentrantLock1

reentrantlock用于替代synchronized
本例中由于m1锁定this,只有m1执行完毕的时候,m2才能执行
这里是复习synchronized最原始的语义

import java.util.concurrent.TimeUnit;
public class ReentrantLock1 {
	synchronized void m1() {  //锁定的是this对象
		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 rl = new ReentrantLock1();
		new Thread(rl::m1).start();
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		new Thread(rl::m2).start();
	}
}

ReentrantLock2

reentrantlock用于替代synchronized
由于m1锁定this,只有m1执行完毕的时候,m2才能执行

使用reentrantlock可以完成同样的功能
需要注意的是，必须要必须要必须要手动释放锁
使用synchronized锁定的话如果遇到异常，jvm会自动释放锁，但是lock必须手动释放锁，因此经常在finally中进行锁的释放

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(); //可以写在try外面
			//ReentrantLock需要手动加锁  相当于synchronized(this)
			for (int i = 0; i < 10; i++) {
				TimeUnit.SECONDS.sleep(1);
				System.out.println(i);
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();//ReentrantLock也需要手动释放锁
		}
	}

	void m2() {
		lock.lock();
		System.out.println("m2 ...");
		lock.unlock();
	}

	public static void main(String[] args) {
		ReentrantLock2 rl = new ReentrantLock2();
		new Thread(rl::m1).start();
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		new Thread(rl::m2).start();
	}
}

ReentrantLock3 （tryLock）

使用reentrantlock可以进行“尝试锁定”tryLock，这样无法锁定，或者在指定时间内无法锁定，线程可以决定是否继续等待

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

public class ReentrantLock3 {
	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();
		}
	}

	/*
	 使用tryLock进行尝试锁定，不管锁定与否，方法都将继续执行
	 可以根据tryLock的返回值来判定是否锁定
	 也可以指定tryLock的时间，由于tryLock(time)抛出异常，所以要注意unclock的处理，必须放到finally中
	*/
	void m2() {
		/*
		//第一种
		boolean locked = lock.tryLock();//尝试一下 拿到，返回值为true,否则为false
		System.out.println("m2 ..." + locked);
		if(locked) lock.unlock();
		*/

		//第二种
		boolean locked = false;
		
		try {
			locked = lock.tryLock(5, TimeUnit.SECONDS);
			System.out.println("m2 ..." + locked);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			if(locked)
				lock.unlock();
		}
		
	}

	public static void main(String[] args) {
		ReentrantLock3 rl = new ReentrantLock3();
		new Thread(rl::m1).start();
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		new Thread(rl::m2).start();
	}
}

ReentrantLock4 （可打断）

使用ReentrantLock还可以调用lockInterruptibly方法，可以对线程interrupt方法做出响应，
在一个线程等待锁的过程中，可以被打断

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Function;

public class ReentrantLock4 {
		
	public static void main(String[] args) {
		Lock lock = new ReentrantLock();
		Thread t1 = new Thread(()->{
			try {
				lock.lock();
				System.out.println("t1 start");
				TimeUnit.SECONDS.sleep(Integer.MAX_VALUE);
				System.out.println("t1 end");
			} catch (InterruptedException e) {
				System.out.println("interrupted!");
			} finally {
				lock.unlock();
			}
		});
		t1.start();
		
		Thread t2 = new Thread(()->{
			boolean lockDudge=false;
			try {
				//lock.lock();// 用lock()方法线程一旦启动不能打断 结果：t1 start 然后一直不动
				//(可以被打断的锁)可以对interrupt()方法做出响应，t2.interrupt()方法打断线程2的等待
				lock.lockInterruptibly();
				if(lock.tryLock())
					lockDudge=true;
				System.out.println("t2 start");
				TimeUnit.SECONDS.sleep(5);
				System.out.println("t2 end");
			} catch (InterruptedException e) {
				System.out.println("interrupted!");
			} finally {
				if(lockDudge==true)
					lock.unlock();
			}
		});
		t2.start();
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t2.interrupt(); //（主线程）打断线程2的等待，因为线程一一直占据锁，所以t2拿不到锁
	}
}

ReentrantLock5

默认Synchronized为非公平锁，线程A，B,C,都去争抢锁，A得到，用完后释放，B等了一天，C等了一秒，结果C先得到锁
这样不公平，但是对于cou来说比较好，效率高，不用计算线程等待时间。

ReentrantLock还可以指定为公平锁（谁等的时间长，谁得到锁），公平锁效率比较低（需要计算等待的时间）

import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLock5 extends Thread {
	private static ReentrantLock lock=new ReentrantLock(true); //参数为true表示为公平锁，请对比输出结果
    public void run() {
        for(int i=0; i<100; i++) {
            lock.lock();
            try{
                System.out.println(Thread.currentThread().getName()+"获得锁");
            }finally{
                lock.unlock();
            }
        }
    }
    public static void main(String[] args) {
        ReentrantLock5 rl=new ReentrantLock5();
        Thread th1=new Thread(rl);
        Thread th2=new Thread(rl);
        th1.start();
        th2.start();
        //理论上t1,t2交替得到锁
        //但是有的时候是t1得到，循环打印100次后t2得到
    }
}

总结

ReentrantLock可以实现Synchronized可以实现的功能，且更加灵活
(1)可以尝试锁定，并且可以指定时间
(2)可以设置为可打断锁
(3)可以设置为公平锁，谁等的时间差，谁优先得到锁