多线程详解第4讲：线程同步（重点）

悠悠 2021-09-07 11:38 344阅读 0赞

## 线程同步 ##

--------------------

### 目录 ###

*   *  线程同步
     *   *  1、并发并发 :
         *  2、线程同步机制
         *  3、三大不安全案例
         *  4、同步方法
         *  5、同步块
         *  6、CopyOnWriteArrayList
         *  7、死锁
         *  8、Lock(锁)
         *  9、synchronized 与 Lock 的对比

### 1、并发并发 : ###

**同一个对象**被**多个线程**同时操作

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70]

### 2、线程同步机制 ###

**线程同步**

*  现实生活中,我们会遇到 ” 同一个资源 , 多个人都想使用 ” 的问题 , 比如,食堂排队打饭 , 每个人都想吃饭 , 最天然的解决办法就是 , 排队 ，一个个来。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 1]

*  处理多线程问题时 , 多个线程访问同一个对象 , 并且某些线程还想修改这个对象 ，这时候我们就需要线程同步 ， 线程同步其实就是一种等待机制 , 多个需要同时访问此对象的线程进入这个**对象的等待池** 形成队列, 等待前面线程使用完毕 , 下一个线程再使用。

**队列 和 锁**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 2]  
由于同一进程的多个线程共享同一块存储空间 , 在带来方便的同时,也带来了访问冲突问题 , 为了保证数据在方法中被访问时的正确性 , 在访问时加入**锁机制** **synchronized** , 当一个线程获得对象的排它锁 , 独占资源 , 其他线程必须等待 , 使用后释放锁即可 ,存在以下问题 :

*  一个线程持有锁会导致其他所有需要此锁的线程挂起 ;
 *  在多线程竞争下 , 加锁 , 释放锁会导致比较多的上下文切换和调度延时,引起性能问题 ;
 *  如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置 , 引起性能问题

### 3、三大不安全案例 ###

**代码模拟**

**1、不安全的买票**

package com.kaung.syn;
    
    //不安全的买票
    public class UnsafeBuyTicket { 
        public static void main(String[] args) { 
            BuyTicket station = new BuyTicket();
    
            new Thread(station,"苦逼的我").start();
            new Thread(station,"牛逼的你们").start();
            new Thread(station,"可恶的黄牛党").start();
        }
    }
    
    
    class BuyTicket implements Runnable{ 
    
        //票
        private int ticketNum = 10;
        boolean flag = true; //外部停止标志
        @Override
        public void run() { 
            while(true){ 
                buy();
            }
        }
        private void buy(){ 
            //判断是否有票
            if(ticketNum <= 0){ 
                flag = false;
                return ;
            }
            //模拟延时
            try { 
                Thread.sleep(100);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            //买票
            System.out.println(Thread.currentThread().getName()+"拿到"+ticketNum--);
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 3]  
**2、不安全的银行取钱**

package com.kaung.syn;
    
    import java.util.concurrent.ThreadLocalRandom;
    
    //不安全的取钱
    //两个人去银行取钱，账户
    public class UnsafeBank { 
        public static void main(String[] args) { 
            //账户
            Account account = new Account(100,"结婚基金");
    
            Drawing you = new Drawing(account,50,"你");
            Drawing girlFriend = new Drawing(account,100,"girlFriend");
    
            you.start();
            girlFriend.start();
    
        }
    }
    
    //账户
    class Account{ 
         int money; //余额
         String name; //卡名
    
        public Account(int money, String name) { 
            this.money = money;
            this.name = name;
        }
    }
    
    
    //银行：模拟取款
    class Drawing extends Thread{ 
        Account account; //账户
        //取了多少钱
        int drawingMoney;
        //现在手里有多少钱
        int nowMoney;
    
        public Drawing(Account account, int drawingMoney,String name) { 
            super(name);
            this.account = account;
            this.drawingMoney = drawingMoney;
        }
        //取钱
        @Override
        public void run() { 
            //判断有没有钱
            if(account.money - drawingMoney < 0){ 
                System.out.println(Thread.currentThread().getName()+"钱不够，取不下");
                return;
            }
            try { 
                Thread.sleep(1000);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            //卡内余额 = 余额 - 你取的钱
            account.money = account.money - drawingMoney;
            //你手里的钱
            nowMoney = nowMoney + drawingMoney;
    
            System.out.println(account.name+"余额为："+account.money);
            System.out.println(this.getName()+"手里的钱"+nowMoney);
        }
    }

**运行截图**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 4]  
**3、线程不安全的集合**

package com.kaung.syn;
    
    
    import java.util.*;
    import java.util.concurrent.ThreadPoolExecutor;
    
    //线程不安全的集合
    public class UnsafeList { 
        public static void main(String[] args) { 
            List<String> list = new ArrayList<>();
            for (int i = 0; i < 10000; i++) { 
                new Thread(()->{ 
                   list.add(Thread.currentThread().getName());
                }).start();
            }
            try { 
                Thread.sleep(3000);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println(list.size());
        }
    }

**运行截图**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 5]  
我们发现集合中的元素并没有到达10000，少了2个。这是因为多个线程抢占同一个资源，就会出现多个线程添加到了同一个位置。

**每个线程在自己的工作内存交互，内存控制不当会造成数据不一致**

### 4、同步方法 ###

**同步方法**

*  由于我们可以通过 private 关键字来保证数据对象只能被方法访问 , 所以我们只需要针对方法提出一套机制 , 这套机制就是 synchronized 关键字 , 它包括两种用法 : synchronized 方法 和synchronized 块 .
    
    同步方法 : `public synchronized void method(int args) {}`
 *  synchronized方法控制对 “对象” 的访问 , 每个对象对应一把锁 , 每个 synchronized方法都必须获得调用该方法的对象的锁才能执行 , 否则线程会阻塞 , 方法一旦执行 , 就独占该锁 , 直到该方法返回才释放锁 , 后面被阻塞的线程才能获得这个锁 , 继续执行。
    
    缺陷 : **若将一个大的方法申明为synchronized** **将会影响效率**

**同步方法弊端**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 6]

### 5、同步块 ###

**同步块**

*  同步块 : `synchronized (Obj ) { }`
 *  **Obj** 称之为 **同步监视器**
    
     *  **Obj** 可以是任何对象 , 但是推荐使用共享资源作为同步监视器
     *  同步方法中无需指定同步监视器 , 因为同步方法的同步监视器就是this , 就是 这个对象本身 , 或者是 class \[ 反射中讲解 \]
 *  同步监视器的执行过程
    
    1.  第一个线程访问 , 锁定同步监视器 , 执行其中代码 .
    2.  第二个线程访问 , 发现同步监视器被锁定 , 无法访问
    3.  第一个线程访问完毕 , 解锁同步监视器
    4.  第二个线程访问, 发现同步监视器没有锁 , 然后锁定并访问

**对三大不安全案例的改造**

**1、安全的买票**

package com.kaung.syn;
    
    //不安全的买票
    public class UnsafeBuyTicket { 
        public static void main(String[] args) { 
            BuyTicket station = new BuyTicket();
    
            new Thread(station,"苦逼的我").start();
            new Thread(station,"牛逼的你们").start();
            new Thread(station,"可恶的黄牛党").start();
        }
    }
    
    
    class BuyTicket implements Runnable{ 
    
        //票
        private int ticketNum = 10;
        boolean flag = true; //外部停止标志
        @Override
        public void run() { 
            while(flag){ 
                try { 
                    buy();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
        }
        // synchronized 同步方法，锁的是this
        private synchronized void buy() throws InterruptedException { 
            //判断是否有票
            if(ticketNum <= 0){ 
                flag = false;
                return ;
            }
            //模拟延时
    
            Thread.sleep(100);
    
            //买票
            System.out.println(Thread.currentThread().getName()+"拿到"+ticketNum--);
        }
    }

**运行截图**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 7]  
**2、安全的取钱**

package com.kaung.syn;
    
    import java.util.concurrent.ThreadLocalRandom;
    
    //不安全的取钱
    //两个人去银行取钱，账户
    public class UnsafeBank { 
        public static void main(String[] args) { 
            //账户
            Account account = new Account(100,"结婚基金");
    
            Drawing you = new Drawing(account,50,"你");
            Drawing girlFriend = new Drawing(account,100,"girlFriend");
    
            you.start();
            girlFriend.start();
    
        }
    }
    
    //账户
    class Account{ 
         int money; //余额
         String name; //卡名
    
        public Account(int money, String name) { 
            this.money = money;
            this.name = name;
        }
    }
    
    
    //银行：模拟取款
    class Drawing extends Thread{ 
        Account account; //账户
        //取了多少钱
        int drawingMoney;
        //现在手里有多少钱
        int nowMoney;
    
        public Drawing(Account account, int drawingMoney,String name) { 
            super(name);
            this.account = account;
            this.drawingMoney = drawingMoney;
        }
        //取钱
        //synchronized 默认锁的是this
        @Override
        public  void run() { 
            //锁的对象是变化的量，需要增删改的对象
            synchronized ( account){ 
                //判断有没有钱
                if(account.money - drawingMoney < 0){ 
                    System.out.println(Thread.currentThread().getName()+"钱不够，取不下");
                    return;
                }
                try { 
                    Thread.sleep(1000);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                //卡内余额 = 余额 - 你取的钱
                account.money = account.money - drawingMoney;
                //你手里的钱
                nowMoney = nowMoney + drawingMoney;
    
                System.out.println(account.name+"余额为："+account.money);
                System.out.println(this.getName()+"手里的钱"+nowMoney);
            }
        }
    }

**运行截图**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 8]  
**3、线程安全的集合**

package com.kaung.syn;
    
    
    import java.util.*;
    import java.util.concurrent.ThreadPoolExecutor;
    
    //线程不安全的集合
    public class UnsafeList { 
        public static void main(String[] args) { 
            List<String> list = new ArrayList<>();
            for (int i = 0; i < 10000; i++) { 
                new Thread(()->{ 
                    synchronized (list){ 
                        list.add(Thread.currentThread().getName());
                    }
                }).start();
            }
            //休眠主线程，避免主线程执行过快，run线程还未执行完毕就打印结果。
            try { 
                Thread.sleep(3000);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println(list.size());
        }
    }

**运行截图**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 9]  
**总结**

锁的对象是变化的量，需要增删改的对象。锁住大家都操作的共同资源，避免共同资源在同一时间被多个对象访问。

### 6、CopyOnWriteArrayList ###

**线程安全的集合**

package com.kaung.syn;
    
    import java.util.concurrent.CopyOnWriteArrayList;
    
    //测试JUC安全类型的集合
    public class TestJUC { 
        public static void main(String[] args) { 
            CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
            for (int i = 0; i < 10000; i++) { 
                new Thread(()->{ 
                    list.add(Thread.currentThread().getName());
                }).start();
            }
            try { 
                Thread.sleep(3_000);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println(list.size());
        }
    }

### 7、死锁 ###

**死锁**

多个线程各自占有一些共享资源 , 并且互相等待其他线程占有的资源才能运行 , 而导致两个或者多个线程都在等待对方释放资源 , 都停止执行的情形 . 某一个同步块同时拥有 “ **两个以上对象的锁** ” 时 , 就可能会发生 “ 死锁 ” 的问题 。

**死锁避免方法**

*  产生死锁的四个必要条件：
    
    1.  互斥条件：一个资源每次只能被一个进程使用。
    2.  请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
    3.  不剥夺条件 : 进程已获得的资源，在末使用完之前，不能强行剥夺。
    4.  循环等待条件 : 若干进程之间形成一种头尾相接的循环等待资源关系。

上面列出了死锁的四个必要条件，我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生。

**代码模拟死锁**

package com.kuang.thread;
    
    
    
    //死锁：多个线程互相抱着对方需要的资源，然后形成僵持
    public class DeadLock { 
        public static void main(String[] args) { 
            Makeup g1 = new Makeup(0,"灰姑娘");
            Makeup g2 = new Makeup(1,"白雪公主");
    
            g1.start();
            g2.start();
        }
    }
    
    //口红
    class Lipstick{ 
    
    }
    //镜子
    class Mirror{ 
    
    }
    class Makeup extends Thread { 
        //需要的资源只有一份，用static来保证只要一份
        static Lipstick lipstick = new Lipstick();
        static Mirror mirror = new Mirror();
    
        int choice; //选择
        String girlName; //使用化妆品的人
    
        Makeup(int choice, String girlName) { 
            this.choice = choice;
            this.girlName = girlName;
        }
    
        @Override
        public void run() { 
            //化妆
            try { 
                makeup();
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }
    
        //化妆，互相持有对方的锁，就是需要拿到对方的资源
        private void makeup() throws InterruptedException { 
            if (choice == 0) {   //获得口红的锁
                synchronized (lipstick) { 
                    System.out.println(this.girlName + "获得口红的锁");
                    Thread.sleep(1000);
                    synchronized (mirror) { //一秒钟后想获得镜子
                        System.out.println(this.girlName + "获得镜子的锁");
                    }
                }
            } else { 
                synchronized (mirror) { 
                    System.out.println(this.girlName + "获得镜子的锁");
                    Thread.sleep(2000);
                    synchronized (lipstick) { //一秒钟后想获得口红
                        System.out.println(this.girlName + "获得口红的锁");
                    }
                }
            }
        }
    }

程序运行卡死，互相僵持。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 10]

### 8、Lock(锁) ###

**Lock(锁)**

*  从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当
 *  `java.util.concurrent.locks.Lock`接口是控制多个线程对共享资源进行访问的工具。 锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
 *  ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁

**测试lock锁**

package com.kuang.gaoji;
    
    import java.util.concurrent.locks.ReentrantLock;
    
    //测试lock锁
    public class TestLock { 
        public static void main(String[] args) { 
            TestLock2 testLock2 = new TestLock2();
    
            new Thread(testLock2).start();
            new Thread(testLock2).start();
            new Thread(testLock2).start();
        }
    }
    
    class TestLock2 implements Runnable{ 
        int ticketNums = 10;
    
        //定义lock锁
        private final ReentrantLock lock = new ReentrantLock();
        @Override
        public void run() { 
            while(true){ 
    
                try{ 
                    lock.lock(); //加锁
                    if(ticketNums>0){ 
                        try { 
                            Thread.sleep(1000);
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
                        System.out.println(ticketNums--);
                    }else { 
                        break;
                    }
                }finally { 
                   //解锁
                    lock.unlock();
                }
            }
        }
    }

**运行截图**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 11]

### 9、synchronized 与 Lock 的对比 ###

*  Lock是显式锁（手动开启和关闭锁，别忘记关闭锁）synchronized是隐式锁，出了作用域自动释放
 *  Lock只有代码块锁，synchronized有代码块锁和方法锁
 *  使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
 *  优先使用顺序：
    
     *  Lock > 同步代码块（已经进入了方法体，分配了相应资源）> 同步方法（在方法体之外）

--------------------

**多线程详解系列文章目录**

[多线程详解第1讲：线程简介][1]

[多线程详解第2讲：线程实现（重点）][2]

[多线程详解第3讲：线程状态][3]

[多线程详解第4讲：线程同步（重点）][4]

[多线程详解第5讲：线程协作][5]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70]: /images/20210724/02b5407ca1fc458d95e5a1f9d152d049.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 1]: /images/20210724/b0199012a9764680a6fe4aad4f9ffaa7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 2]: /images/20210724/542567e61bb94d62bdfa4260b3265719.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 3]: /images/20210724/d41c1c581e3c486597c579202e40a2ff.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 4]: /images/20210724/26b05c313b764e5ca91687844a5c5186.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 5]: /images/20210724/60df3ebcbab64c5e9f130aa43b063bb5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 6]: /images/20210724/66952058476a4145be0fe80d339b9c5e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 7]: /images/20210724/e20452b33795499cb621cedf32207e34.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 8]: /images/20210724/8ec7ff6938cc4fc79e82d19e0ac393f6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 9]: /images/20210724/f12777dac72049d9814b9ac0ab122630.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 10]: /images/20210724/5a91c3766f674b83b907a91e2d1d1acc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 11]: /images/20210724/9fdaf4ef22924fc7adf97d04f9c78f3c.png
[1]: https://blog.csdn.net/weixin_45629285/article/details/116034361
[2]: https://blog.csdn.net/weixin_45629285/article/details/116034464
[3]: https://blog.csdn.net/weixin_45629285/article/details/116064500
[4]: https://blog.csdn.net/weixin_45629285/article/details/116065351
[5]: https://blog.csdn.net/weixin_45629285/article/details/116065982