十五、ReentrantLock

synchronized本身是可重入锁

下述示例代码：

当i = 2的时候会执行m2的synchronized锁


import java.util.concurrent.TimeUnit;public class T01_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);if(i == 2) m2();}}synchronized void m2() {System.out.println("m2 ...");}public static void main(String[] args) {T01_ReentrantLock1 rl = new T01_ReentrantLock1();new Thread(rl::m1).start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}//new Thread(rl::m2).start();}
}

/*** reentrantlock用于替代synchronized* 本例中由于m1锁定this,只有m1执行完毕的时候,m2才能执行* 这里是复习synchronized最原始的语义*/
package com.mashibing.juc.c_020;import java.util.concurrent.TimeUnit;public class T01_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);
//			if(i == 2) m2();}}synchronized void m2() {System.out.println("m2 ...");}public static void main(String[] args) {T01_ReentrantLock1 rl = new T01_ReentrantLock1();new Thread(rl::m1).start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}new Thread(rl::m2).start();}
}

ReentrantLock 可重入锁

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

reentrantlock用于替代synchronized

synchronized是自动解锁的

reentrantlock是手动解锁的


import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class T02_ReentrantLock2 {Lock lock = new ReentrantLock();void m1() {try {lock.lock(); //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();}}void m2() {try {lock.lock();System.out.println("m2 ...");} finally {lock.unlock();}}public static void main(String[] args) {T02_ReentrantLock2 rl = new T02_ReentrantLock2();new Thread(rl::m1).start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}new Thread(rl::m2).start();}
}

tryLock尝试锁

使用tryLock进行尝试锁定，不管锁定与否，方法都将继续执行

可以根据tryLock的返回值来判定是否锁定
也可以指定tryLock的时间，由于tryLock(time)抛出异常，所以要注意unclock的处理，必须放到finally中


import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class T03_ReentrantLock3 {Lock lock = new ReentrantLock();void m1() {try {lock.lock();for (int i = 0; i < 3; 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();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) {T03_ReentrantLock3 rl = new T03_ReentrantLock3();new Thread(rl::m1).start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}new Thread(rl::m2).start();}
}

可以尝试锁

可以被打断的加锁


import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Function;public class T04_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(()->{try {//lock.lock();lock.lockInterruptibly(); //可以对interrupt()方法做出响应System.out.println("t2 start");TimeUnit.SECONDS.sleep(5);System.out.println("t2 end");} catch (InterruptedException e) {System.out.println("interrupted!");} finally {lock.unlock();}});t2.start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}t2.interrupt(); //打断线程2的等待}
}

new ReentrantLock(true)

当线程位于一个线程队列里面，当又有一个新的线程来的时候，他会检查队列里面有没有原来内容，如果不公平，这个线程上来就抢是有可能抢到的，如果是公平锁，这个线程会先检查这个线程里面有没有原来等着的，队列里如果有，它先进队列等着，等别人先去运行，队列里如果没有，我先来

在 Java 中，ReentrantLock 类提供了公平性选择，可以通过构造函数 ReentrantLock(boolean fair) 来指定锁的公平性。当创建 ReentrantLock 对象时，如果指定 fair 参数为 true，则表示这是一个公平锁，如果为 false，则表示是一个非公平锁。

公平锁：在公平锁模式下，线程会按照先来先服务的顺序获取锁。当一个线程尝试获取锁时，如果锁已经被其他线程持有，该线程会被放入等待队列中，按照先后顺序等待获取锁。

非公平锁：在非公平锁模式下，线程尝试获取锁时会直接尝试获取，不考虑等待队列中是否有等待的线程。这种模式下，新来的线程有可能会插队，直接抢占锁，可能会导致等待时间更短。

mport java.util.concurrent.locks.ReentrantLock;public class T05_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) {T05_ReentrantLock5 rl=new T05_ReentrantLock5();Thread th1=new Thread(rl);Thread th2=new Thread(rl);th1.start();th2.start();}
}