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

你的名字 2023-09-24 16:47 66阅读 0赞

# 1.多把锁 #

## 多把不相干的锁 ##

一间大屋子有两个功能：睡觉、学习，互不相干。  
现在小南要学习，小女要睡觉，但如果只用一间屋子（一个对象锁）的话，那么并发度很低  
解决方法是准备多个房间（多个对象锁）

class BigRoom {
        
    	public void sleep() {
        
    		synchronized (this) {
        
    		log.debug("sleeping 2 小时");
    		Sleeper.sleep(2);
    		}
    	}
    	public void study() {
        
    		synchronized (this) {
        
    		log.debug("study 1 小时");
    		Sleeper.sleep(1);
    		}
    	}
    }

**改进后的代码：**

12:13:54.471 [小南] c.BigRoom - study 1 小时
    12:13:55.476 [小女] c.BigRoom - sleeping 2 小时

BigRoom bigRoom = new BigRoom();
    new Thread(() -> {
        
    	bigRoom.compute();
    	},"小南").start();
    new Thread(() -> {
        
    	bigRoom.sleep();
    	},"小女").start();

public class TestMultiLock {
        
        public static void main(String[] args) {
        
            BigRoom bigRoom = new BigRoom();
            new Thread(() -> {
        
                bigRoom.study();
            },"小南").start();
            new Thread(() -> {
        
                bigRoom.sleep();
            },"小女").start();
        }
    }
    
    @Slf4j(topic = "c.BigRoom")
    class BigRoom {
        
    
        private final Object studyRoom = new Object();
    
        private final Object bedRoom = new Object();
    
        public void sleep() {
        
            synchronized (bedRoom) {
        
                log.debug("sleeping 2 小时");
                Sleeper.sleep(2);
            }
        }
    
        public void study() {
        
            synchronized (studyRoom) {
        
                log.debug("study 1 小时");
                Sleeper.sleep(1);
            }
        }
    
    }

10:07:25.797 c.BigRoom [小南] - study 1 小时
    10:07:25.797 c.BigRoom [小女] - sleeping 2 小时

*将锁的粒度细分：*

*  好处，是可以增强并发度
 *  坏处，如果一个线程需要同时获得多把锁，就容易发生死锁

# 2.活跃性 #

## 2.1死锁 ##

有这样的情况：一个线程需要同时获取多把锁，这时就容易发生死锁  
t1 线程 获得 A对象 锁，接下来想获取 B对象的锁 t2 线程 获得 B对象 锁，接下来想获取 A对象的锁

### 代码 ###

public class Test5 extends Thread {
        
        public static void main(String[] args) throws InterruptedException {
        
            Object A = new Object();
            Object B = new Object();
            Thread t1 = new Thread(() -> {
        
                synchronized (A) {
        
                    log.debug("lock A");
                    try {
        
                        sleep(2);
                    } catch (InterruptedException e) {
        
                        throw new RuntimeException(e);
                    }
                    synchronized (B) {
        
                        log.debug("lock B");
                        log.debug("操作...");
                    }
                }
            }, "t1");
            Thread t2 = new Thread(() -> {
        
                synchronized (B) {
        
                    log.debug("lock B");
                    try {
        
                        sleep(1);
                    } catch (InterruptedException e) {
        
                        throw new RuntimeException(e);
                    }
                    synchronized (A) {
        
                        log.debug("lock A");
                        log.debug("操作...");
                    }
                }
            }, "t2");
            t1.start();
            t2.start();
    
        }
    }

### 运行结果 ###

10:29:05.934 c.Test5 [t1] - lock A
    10:29:05.934 c.Test5 [t2] - lock B

## 2.2定位死锁 ##

*  避免死锁要注意加锁顺序
 *  另外如果由于某个线程进入了死循环，导致其它线程一直等待，对于这种情况 linux 下可以通过 top 先定位到CPU 占用高的 Java 进程，再利用 top -Hp 进程id 来定位是哪个线程，最后再用 jstack 排查

### 方法1：使用jstack ###

检使用 jps 定位进程 id，再用 jstack 定位死锁：  
![在这里插入图片描述][af2775efe6f6498a92ecc47f80931bcf.png]  
![在这里插入图片描述][72d2ecf091f8421899833694b2d9927f.png]

### 方法2：使用jconsole ###

![在这里插入图片描述][39e5229193b14a5d9d55d74617166425.png]  
![在这里插入图片描述][50aed9919aa34d5f8f335e698b2a03f0.png]  
![在这里插入图片描述][bbb266f12171426a924b8ae98bddf4ae.png]  
![在这里插入图片描述][a738f6a048e847bf918634153716de98.png]

### 问题分析（哲学家就餐问题） ###

![在这里插入图片描述][142989d37c8b4afea1c1f110251d7dc2.png]  
有五位哲学家，围坐在圆桌旁。  
他们只做两件事，思考和吃饭，思考一会吃口饭，吃完饭后接着思考。  
吃饭时要用两根筷子吃，桌上共有 5 根筷子，每位哲学家左右手边各有一根筷子。  
如果筷子被身边的人拿着，自己就得等待

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 {
        
        String name;
    
        public Chopstick(String name) {
        
            this.name = name;
        }
    
        @Override
        public String toString() {
        
            return "筷子{" + name + '}';
        }
    }

12:33:15.575 [苏格拉底] c.Philosopher - eating...
    12:33:15.575 [亚里士多德] c.Philosopher - eating...
    12:33:16.580 [阿基米德] c.Philosopher - eating...
    12:33:17.580 [阿基米德] c.Philosopher - eating...
    // 卡在这里, 不向下运行

![在这里插入图片描述][294ccc63ee0d42baaa40091c3d9a4cf9.png]

-------------------------------------------------------------------------
    名称: 阿基米德
    状态: cn.itcast.Chopstick@1540e19d (筷子1) 上的BLOCKED, 拥有者: 苏格拉底
    总阻止数: 2, 总等待数: 1
    堆栈跟踪:
    cn.itcast.Philosopher.run(TestDinner.java:48)
    - 已锁定 cn.itcast.Chopstick@6d6f6e28 (筷子5)
    -------------------------------------------------------------------------
    名称: 苏格拉底
    状态: cn.itcast.Chopstick@677327b6 (筷子2) 上的BLOCKED, 拥有者: 柏拉图
    总阻止数: 2, 总等待数: 1
    堆栈跟踪:
    cn.itcast.Philosopher.run(TestDinner.java:48)
    - 已锁定 cn.itcast.Chopstick@1540e19d (筷子1)
    -------------------------------------------------------------------------
    名称: 柏拉图
    状态: cn.itcast.Chopstick@14ae5a5 (筷子3) 上的BLOCKED, 拥有者: 亚里士多德
    总阻止数: 2, 总等待数: 0
    堆栈跟踪:
    cn.itcast.Philosopher.run(TestDinner.java:48)
    - 已锁定 cn.itcast.Chopstick@677327b6 (筷子2)
    -------------------------------------------------------------------------
    名称: 亚里士多德
    状态: cn.itcast.Chopstick@7f31245a (筷子4) 上的BLOCKED, 拥有者: 赫拉克利特
    总阻止数: 1, 总等待数: 1
    堆栈跟踪:
    cn.itcast.Philosopher.run(TestDinner.java:48)
    - 已锁定 cn.itcast.Chopstick@14ae5a5 (筷子3)
    -------------------------------------------------------------------------
    名称: 赫拉克利特
    状态: cn.itcast.Chopstick@6d6f6e28 (筷子5) 上的BLOCKED, 拥有者: 阿基米德
    总阻止数: 2, 总等待数: 0
    堆栈跟踪:
    cn.itcast.Philosopher.run(TestDinner.java:48)
    - 已锁定 cn.itcast.Chopstick@7f31245a (筷子4)

#### 解决问题办法：使用ReentrantLock ####

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 + '}';
        }
    }

11:20:54.317 c.Philosopher [亚里士多德] - eating...
    11:20:54.316 c.Philosopher [苏格拉底] - eating...
    11:20:55.330 c.Philosopher [赫拉克利特] - eating...
    11:20:55.330 c.Philosopher [柏拉图] - eating...
    11:20:56.343 c.Philosopher [柏拉图] - eating...
    11:20:56.343 c.Philosopher [阿基米德] - eating...
    11:20:57.347 c.Philosopher [亚里士多德] - eating...
    11:20:57.347 c.Philosopher [苏格拉底] - eating...
    //一直执行下去

![在这里插入图片描述][eaac9e5ce11c434490e9f3e7f5911b19.png]

这种线程没有按预期结束，执行不下去的情况，归类为`【活跃性】`问题，除了死锁以外，还有`活锁`和`饥饿者`两种情况

## 2.3活锁 ##

活锁出现在两个线程互相改变对方的结束条件，最后谁也无法结束，例如

public class TestLiveLock {
        
        static volatile int count = 10;
        static final Object lock = new Object();
    
        public static void main(String[] args) {
        
            new Thread(() -> {
        
                // 期望减到 0 退出循环
                while (count > 0) {
        
                    sleep(0.2);
                    count--;
                    log.debug("count: {}", count);
                }
            }, "t1").start();
            new Thread(() -> {
        
                // 期望超过 20 退出循环
                while (count < 20) {
        
                    sleep(0.2);
                    count++;
                    log.debug("count: {}", count);
                }
            }, "t2").start();
        }
    }

## 2.4饥饿 ##

**没有死锁，但是有些线程无法得到执行**

根据哲学家的案列，修改顺序new Philosopher(“阿基米德”, c1, c5).start();

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("阿基米德", c1, 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 {
        
        String name;
    
        public Chopstick(String name) {
        
            this.name = name;
        }
    
        @Override
        public String toString() {
        
            return "筷子{" + name + '}';
        }
    }

![在这里插入图片描述][0ebd25a9c3994f329149246c2635ecdf.png]  
**没有出现死锁，但是有的线程执行次数多，有的线程执行次数少**

很多教程中把饥饿定义为，一个线程由于优先级太低，始终得不到 CPU 调度执行，也不能够结束，饥饿的情况不易演示，讲读写锁时会涉及饥饿问题  
下面我讲一下我遇到的一个线程饥饿的例子，先来看看使用顺序加锁的方式解决之前的死锁问题

**死锁问题**

![在这里插入图片描述][0f3830b207ab41adbe5671e4c20fb501.png]

**顺序加锁的解决方案**

> **虽然没有出现死锁，但是有的线程执行次数多，有的线程执行次数少**  
> 解决方法：ReentrantLock  
> ![在这里插入图片描述][4b921b4c39da44d7b8b59b771018ab27.png]

[af2775efe6f6498a92ecc47f80931bcf.png]: https://img-blog.csdnimg.cn/af2775efe6f6498a92ecc47f80931bcf.png
[72d2ecf091f8421899833694b2d9927f.png]: https://img-blog.csdnimg.cn/72d2ecf091f8421899833694b2d9927f.png
[39e5229193b14a5d9d55d74617166425.png]: https://img-blog.csdnimg.cn/39e5229193b14a5d9d55d74617166425.png
[50aed9919aa34d5f8f335e698b2a03f0.png]: https://img-blog.csdnimg.cn/50aed9919aa34d5f8f335e698b2a03f0.png
[bbb266f12171426a924b8ae98bddf4ae.png]: https://img-blog.csdnimg.cn/bbb266f12171426a924b8ae98bddf4ae.png
[a738f6a048e847bf918634153716de98.png]: https://img-blog.csdnimg.cn/a738f6a048e847bf918634153716de98.png
[142989d37c8b4afea1c1f110251d7dc2.png]: https://img-blog.csdnimg.cn/142989d37c8b4afea1c1f110251d7dc2.png
[294ccc63ee0d42baaa40091c3d9a4cf9.png]: https://img-blog.csdnimg.cn/294ccc63ee0d42baaa40091c3d9a4cf9.png
[eaac9e5ce11c434490e9f3e7f5911b19.png]: https://img-blog.csdnimg.cn/eaac9e5ce11c434490e9f3e7f5911b19.png
[0ebd25a9c3994f329149246c2635ecdf.png]: https://img-blog.csdnimg.cn/0ebd25a9c3994f329149246c2635ecdf.png
[0f3830b207ab41adbe5671e4c20fb501.png]: https://img-blog.csdnimg.cn/0f3830b207ab41adbe5671e4c20fb501.png
[4b921b4c39da44d7b8b59b771018ab27.png]: https://img-blog.csdnimg.cn/4b921b4c39da44d7b8b59b771018ab27.png