ReentrantLock

特性

相对于 synchronized 它具备如下特点

• 可中断
• 可以设置超时时间
• 可以设置为公平锁
• 支持多个条件变量

---

基本语法

reentrantLock.lock();
try {
    // 临界区代码
} finally {
    // 释放锁
    reentrantLock.unlock();
}

---

可重入

可重入是指同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁，如果是不可重入锁，那么第二次获得锁时，自己也会被锁挡住

public class Test05 {

    private static ReentrantLock reentrantLock = new ReentrantLock();

    public static void main(String[] args) {
        reentrantLock.lock();
        try {
            // 临界区代码
            method1();
        } finally {
            // 释放锁
            reentrantLock.unlock();
        }
    }

    public static void method1() {
        reentrantLock.lock();
        try {
            System.out.println("重入");
        } finally {
            reentrantLock.unlock();
        }
    }
    
}

可打断

@Slf4j
public class Test06 {

    private static ReentrantLock reentrantLock = new ReentrantLock();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            try {
                // 如果没有竞争该方法就会获得lock对象锁
                // 如果有竞争就进入阻塞队列，那么就可以被其他线程用interrupt方法打断
                log.info("尝试获取锁");
                reentrantLock.lockInterruptibly();
            } catch (InterruptedException e) {
                e.printStackTrace();
                log.info("没有获得锁，返回");
                return;
            }
            try {
                log.info("获得锁");
            } finally {
                reentrantLock.unlock();
            }
        }, "t1");

        reentrantLock.lock();
        t1.start();

        try {
            sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("打断");
        t1.interrupt();
    }

}

如果用lockInterruptibly()方法尝试获得锁，那么可以被打断进入catch代码块,避免死等的情况

---

锁超时

@Slf4j
public class Test07 {

    private static ReentrantLock reentrantLock = new ReentrantLock();

    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            log.info("尝试获得锁");
            try {
                // 如果其他线程在1秒内释放锁，那么它可以获得该锁，如果1秒内获取不到就不会等待了，异常是可以进行打断后跳转
                if (! reentrantLock.tryLock(2, TimeUnit.SECONDS)) {
                    log.info("获取不到锁");
                    return;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                log.info("获取到锁");
            } finally {
                reentrantLock.unlock();
            }
        }, "t1");

        reentrantLock.lock();
        log.info("主线程已经先获得该锁");
        
        thread.start();
        
        try {
            sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        reentrantLock.unlock();
    }

}

---

哲学家问题

package thread;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author pangjian
 * @ClassName Question
 * @Description 哲学家问题求解，防止产生死锁
 * @date 2021/11/3 11:31
 */
public class Question {

    public static void main(String[] args) {
        Chopstick c1 = new Chopstick("1");
        Chopstick c2 = new Chopstick("1");
        Chopstick c3 = new Chopstick("1");
        Chopstick c4 = new Chopstick("1");
        Chopstick c5 = new Chopstick("1");

        new Philosopher("小红", c1, c2).start();
        new Philosopher("小亮", c2, c3).start();
        new Philosopher("小明", c3, c4).start();
        new Philosopher("小李", c4, c5).start();
        new Philosopher("小张", c5, c1).start();
    }

}

/**
 * @Description:多个哲学家其实相当于线程
 * @date 2021/11/3 11:41
*/
@Slf4j
class Philosopher extends Thread {

    Chopstick left;
    Chopstick right;

    public Philosopher(String name, Chopstick left, Chopstick right) {
        super(name);
        this.left = left;
        this.right = right;
    }

    @Override
    public void run() {
        while (true) {
            // 尝试获得左手筷子
            if (left.tryLock()) {
                try {
                    // 尝试获得右手筷子，获取不到代码向下执行就放下了左手筷子
                    if (right.tryLock()) {
                        try {
                            eat();
                        } finally {
                            right.unlock();
                        }
                    }
                } finally {
                    left.unlock();
                }
            }
        }
    }


    private void eat() {
        log.info("eating...");
    }


}

/**
 * @Description: 共享资源加锁，筷子
 * @date 2021/11/3 11:40
*/
@Data
@AllArgsConstructor
class Chopstick extends ReentrantLock {

    String name;

}

---

条件变量

• 互斥:使用synchronized 或Lock达到共享资源互斥效果
• 同步:使用wait/notify或Lock的条件变量来达到线程间通信效果（生产者消费者问题）

@Slf4j
public class Test08 {

    static ReentrantLock ROOM = new ReentrantLock();

    static volatile boolean hasCigrette = false;
    static volatile boolean hasBreakfast = false;

    // 等待烟的队列
    static Condition waitCigaretteQueue = ROOM.newCondition();
    // 等待外卖的队列
    static Condition waitbreakfastQueue = ROOM.newCondition();

    public static void main(String[] args) {
        new Thread(() -> {
            ROOM.lock();
            try {
                log.info("有烟没？[{}]", hasCigrette);
                while (! hasCigrette) {
                    log.info("没有不干活");
                    try {
                        // 没有烟进入专属条件队列
                        waitCigaretteQueue.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.info("有烟没？[{}]", hasCigrette);
                if (hasCigrette) {
                    log.info("有烟干活");
                }
            } finally {
                ROOM.unlock();
            }
        }, "小南").start();

        new Thread(() -> {
            ROOM.lock();
            try {
                log.info("外卖送到没？[{}]", hasCigrette);
                while (! hasCigrette) {
                    log.info("没有不干活了");
                    try {
                        // 没有烟进入专属条件队列
                        waitbreakfastQueue.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.info("外卖送到没？[{}]", hasCigrette);
                if (hasCigrette) {
                    log.info("有外卖干活");
                }
            } finally {
                ROOM.unlock();
            }
        }, "小北").start();

        try {
            sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            ROOM.lock();
            try {
                hasCigrette = true;
                // 唤醒该队列内的线程
                waitCigaretteQueue.signal();
            } finally {
                ROOM.unlock();
            }
        }, "送烟的").start();

        new Thread(() -> {
            ROOM.lock();
            try {
                hasBreakfast = true;
                // 唤醒该队列内的线程
                waitbreakfastQueue.signal();
            } finally {
                ROOM.unlock();
            }
        }, "送外卖的").start();
        
    }
    
}