JUC并发编程(9.Java线程）

淩亂°似流年 2023-09-24 17:09 42阅读 0赞

# 1.ReentrantLock #

相对于 synchronized 它具备如下特点

*  `可中断`
 *  `可以设置超时时间`
 *  `可以设置为公平锁`
 *  `支持多个条件变量`  
    与 synchronized 一样，都`支持可重入`

**基本语法**

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

## 1.1 可重入 ##

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

public class Test22 {
        
        private static ReentrantLock lock = new ReentrantLock();
    
        public static void main(String[] args) {
        
            method1();
        }
        public static void method1() {
        
            lock.lock();
            try {
        
                log.debug("execute method1");
                method2();
            } finally {
        
                lock.unlock();
            }
        }
        public static void method2() {
        
            lock.lock();
            try {
        
                log.debug("execute method2");
                method3();
            } finally {
        
                lock.unlock();
            }
        }
        public static void method3() {
        
            lock.lock();
            try {
        
                log.debug("execute method3");
            } finally {
        
                lock.unlock();
            }
        }
    }

20:50:36.487 c.Test22 [main] - execute method1
    20:50:36.488 c.Test22 [main] - execute method2
    20:50:36.488 c.Test22 [main] - execute method3

## 1.2 可打断 ##

public class Test22 {
        
        private static ReentrantLock lock = new ReentrantLock();
    
        public static void main(String[] args) {
        
            Thread t1 = new Thread(() -> {
        
                log.debug("启动...");
                try {
        
                    lock.lockInterruptibly();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                    log.debug("等锁的过程中被打断");
                    return;
                }
                try {
        
                    log.debug("获得了锁");
                } finally {
        
                    lock.unlock();
                }
            }, "t1");
            lock.lock();
            log.debug("获得了锁");
            t1.start();
            try {
        
                sleep(1);
                t1.interrupt();
                log.debug("执行打断");
            } finally {
        
                lock.unlock();
            }
        }
    }

20:42:42.035 c.Test22 [main] - 获得了锁
    20:42:42.037 c.Test22 [t1] - 启动...
    20:42:43.053 c.Test22 [main] - 执行打断
    20:42:43.056 c.Test22 [t1] - 等锁的过程中被打断
    java.lang.InterruptedException
    	at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:898)
    	at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1222)
    	at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:335)
    	at cn.itcast.test.Test22.lambda$main$0(Test22.java:19)
    	at java.lang.Thread.run(Thread.java:748)

> 注意如果是不可中断模式，那么即使使用了 interrupt 也不会让等待中断

public class Test22 {
        
        private static ReentrantLock lock = new ReentrantLock();
    
        public static void main(String[] args) {
        
            Thread t1 = new Thread(() -> {
        
                log.debug("启动...");
                lock.lock();
                try {
        
                    log.debug("获得了锁");
                } finally {
        
                    lock.unlock();
                }
            }, "t1");
            lock.lock();
            log.debug("获得了锁");
            t1.start();
            try {
        
                sleep(1);
                t1.interrupt();
                log.debug("执行打断");
                sleep(1);
            } finally {
        
                log.debug("释放了锁");
                lock.unlock();
            }
        }
    }

20:53:53.599 c.Test22 [main] - 获得了锁
    20:53:53.600 c.Test22 [t1] - 启动...
    20:53:54.602 c.Test22 [main] - 执行打断
    20:53:55.607 c.Test22 [main] - 释放了锁
    20:53:55.607 c.Test22 [t1] - 获得了锁

## 1.3锁超时 ##

### 立刻失败 ###

public class Test22 {
        
        private static ReentrantLock lock = new ReentrantLock();
    
        public static void main(String[] args) {
        
            Thread t1 = new Thread(() -> {
        
                log.debug("启动...");
                if (!lock.tryLock()) {
        
                    log.debug("获取立刻失败，返回");
                    return;
                }
                try {
        
                    log.debug("获得了锁");
                } finally {
        
                    lock.unlock();
                }
            }, "t1");
            lock.lock();
            log.debug("获得了锁");
            t1.start();
            try {
        
                sleep(2);
            } finally {
        
                lock.unlock();
            }
        }
    }

20:55:13.896 c.Test22 [main] - 获得了锁
    20:55:13.898 c.Test22 [t1] - 启动...
    20:55:13.898 c.Test22 [t1] - 获取立刻失败，返回

### 超时失败 ###

public class Test22 {
        
        private static ReentrantLock lock = new ReentrantLock();
    
        public static void main(String[] args) {
        
            Thread t1 = new Thread(() -> {
        
                log.debug("启动...");
                try {
        
                    if (!lock.tryLock(1, TimeUnit.SECONDS)) {
        
                        log.debug("获取等待 1s 后失败，返回");
                        return;
                    }
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                try {
        
                    log.debug("获得了锁");
                } finally {
        
                    lock.unlock();
                }
            }, "t1");
            lock.lock();
            log.debug("获得了锁");
            t1.start();
            try {
        
                sleep(2);
            } finally {
        
                lock.unlock();
            }
        }
    }

20:56:35.545 c.Test22 [main] - 获得了锁
    20:56:35.547 c.Test22 [t1] - 启动...
    20:56:36.560 c.Test22 [t1] - 获取等待 1s 后失败，返回

### 使用 tryLock 解决哲学家就餐问题 ###

public class TestDeadLock {
        
        public static void main(String[] args) {
        
            Chopstick c1 = new Chopstick("1");
            Chopstick c2 = new Chopstick("2");
            Chopstick c3 = new Chopstick("3");
            Chopstick c4 = new Chopstick("4");
            Chopstick c5 = new Chopstick("5");
            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();
        }
    }
    
    @Slf4j(topic = "c.Philosopher")
    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.debug("eating...");
            Sleeper.sleep(1);
        }
    }
    
    
    
    class Chopstick extends ReentrantLock {
        
        String name;
    
        public Chopstick(String name) {
        
            this.name = name;
        }
    
        @Override
        public String toString() {
        
            return "筷子{" + name + '}';
        }
    }

0:58:12.139 c.Philosopher [亚里士多德] - eating...
    20:58:12.139 c.Philosopher [苏格拉底] - eating...
    20:58:13.149 c.Philosopher [柏拉图] - eating...
    20:58:13.149 c.Philosopher [阿基米德] - eating...
    20:58:14.156 c.Philosopher [柏拉图] - eating...
    20:58:14.156 c.Philosopher [赫拉克利特] - eating...
    20:58:15.169 c.Philosopher [苏格拉底] - eating...
    20:58:15.169 c.Philosopher [亚里士多德] - eating...
    ....

问题是获得左右筷子的哲学家次数并不均匀

使用trylock

@Override
        public void run() {
        
            while (true) {
        
    // 尝试获得左手筷子
                if (left.tryLock()) {
        
                    try {
        
    // 尝试获得右手筷子
                        if (right.tryLock()) {
        
                            try {
        
                                eat();
                            } finally {
        
                                right.unlock();
                            }
                        }
                    } finally {
        
                        left.unlock();
                    }
                }
            }
        }

public class TestDeadLock {
        
        public static void main(String[] args) {
        
            Chopstick c1 = new Chopstick("1");
            Chopstick c2 = new Chopstick("2");
            Chopstick c3 = new Chopstick("3");
            Chopstick c4 = new Chopstick("4");
            Chopstick c5 = new Chopstick("5");
            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();
        }
    }
    
    @Slf4j(topic = "c.Philosopher")
    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.debug("eating...");
            Sleeper.sleep(1);
        }
    }
    
    
    
    class Chopstick extends ReentrantLock {
        
        String name;
    
        public Chopstick(String name) {
        
            this.name = name;
        }
    
        @Override
        public String toString() {
        
            return "筷子{" + name + '}';
        }
    }

21:01:29.301 c.Philosopher [苏格拉底] - eating...
    21:01:29.300 c.Philosopher [亚里士多德] - eating...
    21:01:30.306 c.Philosopher [柏拉图] - eating...
    21:01:30.306 c.Philosopher [阿基米德] - eating...
    21:01:31.321 c.Philosopher [柏拉图] - eating...
    21:01:31.321 c.Philosopher [赫拉克利特] - eating...
    21:01:32.336 c.Philosopher [亚里士多德] - eating...
    21:01:32.336 c.Philosopher [苏格拉底] - eating...
    21:01:33.341 c.Philosopher [阿基米德] - eating...
    21:01:33.341 c.Philosopher [亚里士多德] - eating...
    21:01:34.343 c.Philosopher [苏格拉底] - eating...
    21:01:34.343 c.Philosopher [亚里士多德] - eating...
    21:01:35.355 c.Philosopher [苏格拉底] - eating...
    21:01:35.355 c.Philosopher [亚里士多德] - eating...
    21:01:36.368 c.Philosopher [柏拉图] - eating...
    21:01:36.368 c.Philosopher [赫拉克利特] - eating...

## 1.4公平锁 ##

ReentrantLock 默认是不公平的

### 不公平 ###

强行插入，有机会在中间输出

public class Test22 {
        
        private static ReentrantLock lock = new ReentrantLock(false);
    
        public static void main(String[] args) throws InterruptedException {
        
            lock.lock();
            for (int i = 0; i < 10; i++) {
        
                new Thread(() -> {
        
                    lock.lock();
                    try {
        
                        System.out.println(Thread.currentThread().getName() + " running...");
                    } finally {
        
                        lock.unlock();
                    }
                }, "t" + i).start();
            }
    // 1s 之后去争抢锁
            Thread.sleep(1000);
            new Thread(() -> {
        
                System.out.println(Thread.currentThread().getName() + " start...");
                lock.lock();
                try {
        
                    System.out.println(Thread.currentThread().getName() + " running...");
                } finally {
        
                    lock.unlock();
                }
            }, "强行插入").start();
            lock.unlock();
        }
    }

t1 running...
    t0 running...
    强行插入 start...
    强行插入 running...
    t2 running...
    t7 running...
    t6 running...
    t8 running...
    t3 running...
    t4 running...
    t5 running...
    t9 running...

### **改为公平锁后** ###

public class Test22 {
        
        private static ReentrantLock lock = new ReentrantLock(true);
    
        public static void main(String[] args) throws InterruptedException {
        
            lock.lock();
            for (int i = 0; i < 10; i++) {
        
                new Thread(() -> {
        
                    lock.lock();
                    try {
        
                        System.out.println(Thread.currentThread().getName() + " running...");
                    } finally {
        
                        lock.unlock();
                    }
                }, "t" + i).start();
            }
    // 1s 之后去争抢锁
            Thread.sleep(1000);
            new Thread(() -> {
        
                System.out.println(Thread.currentThread().getName() + " start...");
                lock.lock();
                try {
        
                    System.out.println(Thread.currentThread().getName() + " running...");
                } finally {
        
                    lock.unlock();
                }
            }, "强行插入").start();
            lock.unlock();
        }
    }

t1 running...
    强行插入 start...
    t2 running...
    t0 running...
    t3 running...
    t5 running...
    t4 running...
    t6 running...
    t7 running...
    t8 running...
    t9 running...
    强行插入 running...

## 1.5条件变量 ##

*  `synchronized` 中也`有条件变量`，就是我们讲原理时那个`waitSet` 休息室，当条件不满足时进入 waitSet 等待
 *  `ReentrantLock` 的条件变量比 synchronized 强大之处在于，它是`支持多个条件变量`的，这就好比  
    synchronized 是那些不满足条件的线程都在一间休息室等消息而 **ReentrantLock 支持多间休息室**，有专门等烟的休息室、专门等早餐的休息室、唤醒时也是按休息室来唤醒  
    **使用要点：**
 *  await 前需要获得锁
 *  await 执行后，会释放锁，进入conditionObject 等待
 *  await 的线程被唤醒（或打断、或超时）取重新竞争 lock 锁
 *  竞争 lock 锁成功后，从 await 后继续执行

public class Test24 {
        
        static final Object room = new Object();
        static boolean hasCigarette = false;
        static boolean hasTakeout = false;
        static ReentrantLock ROOM = new ReentrantLock();
        // 等待烟的休息室
        static Condition waitCigaretteSet = ROOM.newCondition();
        // 等外卖的休息室
        static Condition waitTakeoutSet = ROOM.newCondition();
    
        public static void main(String[] args) {
        
    
    
            new Thread(() -> {
        
                ROOM.lock();
                try {
        
                    log.debug("有烟没？[{}]", hasCigarette);
                    while (!hasCigarette) {
        
                        log.debug("没烟，先歇会！");
                        try {
        
                            waitCigaretteSet.await();
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                    log.debug("可以开始干活了");
                } finally {
        
                    ROOM.unlock();
                }
            }, "小南").start();
    
            new Thread(() -> {
        
                ROOM.lock();
                try {
        
                    log.debug("外卖送到没？[{}]", hasTakeout);
                    while (!hasTakeout) {
        
                        log.debug("没外卖，先歇会！");
                        try {
        
                            waitTakeoutSet.await();
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                    log.debug("可以开始干活了");
                } finally {
        
                    ROOM.unlock();
                }
            }, "小女").start();
    
            sleep(1);
            new Thread(() -> {
        
                ROOM.lock();
                try {
        
                    hasTakeout = true;
                    waitTakeoutSet.signal();
                } finally {
        
                    ROOM.unlock();
                }
            }, "送外卖的").start();
    
            sleep(1);
    
            new Thread(() -> {
        
                ROOM.lock();
                try {
        
                    hasCigarette = true;
                    waitCigaretteSet.signal();
                } finally {
        
                    ROOM.unlock();
                }
            }, "送烟的").start();
        }
    
    }

21:25:27.611 c.Test24 [小女] - 外卖送到没？[false]
    21:25:27.615 c.Test24 [小女] - 没外卖，先歇会！
    21:25:27.616 c.Test24 [小南] - 有烟没？[false]
    21:25:27.616 c.Test24 [小南] - 没烟，先歇会！
    21:25:28.611 c.Test24 [小女] - 可以开始干活了
    21:25:29.614 c.Test24 [小南] - 可以开始干活了