• 多线程详解（三）

    目录

    一、线程同步

    二、三大不安全案例

    2.1 买票

    2.2 取钱

    2.3 线程不安全的集合

    三、同步方法及同步块

    3.1 同步方法

    3.2  同步块

    四、死锁 

    4.1 什么是死锁

    4.2 死锁避免方法 

    五、Lock（锁）

    一、线程同步

    1）发生情景：多个线程操作同一个资源

    2）并发：同一个对象被多个线程同时操作

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

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

    3）如何解决线程的安全性： 队列 + 锁

    由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题。为了保证数据在方法中被访问时的正确性，在访问同时加入 锁机制 （synchronized），当一个线程获得对象的排他锁，独占资源时，其他线程必须等待，使用后释放锁即可，存在以下问题：

            a.一个线程持有锁会导致其他所需要此锁的线程挂起

            b.在多线程竞争下，加锁，释放锁，会导致比较多的 上下文切换 和 调度延迟，引起性能问题

            c.如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问

                题

    二、三大不安全案例

    2.1 买票

    案例：模拟不安全的线程

    1. public class UnsafeBuyTicket {
    2.     public static void main(String[] args) {
    3.         BuyTicket buyTicket = new BuyTicket();
    4.  
    5.         new Thread(buyTicket,"A").start();
    6.         new Thread(buyTicket,"B").start();
    7.         new Thread(buyTicket,"C").start();
    8.     }
    9. }
    10.  
    11. class BuyTicket implements Runnable{
    12.     //票
    13.     private int ticketNums = 10;
    14.     //借助外部标志位停止线程
    15.     boolean flag=true;
    16.  
    17.     @Override
    18.     public void run() {
    19.         //买票
    20.         while (flag){
    21.             buy();
    22.         }
    23.     }
    24.  
    25.     private void buy(){
    26.         //判断是否有票
    27.         if(ticketNums<=0){
    28.             flag=false;
    29.             return;
    30.         }
    31.         //模拟延时
    32.         try {
    33.             Thread.sleep(100);
    34.         } catch (InterruptedException e) {
    35.             e.printStackTrace();
    36.         }
    37.         //买票
    38.         System.out.println(Thread.currentThread().getName()+" 拿到 "+ticketNums--);
    39.     }
    40. }

    运行结果：不同的线程抢夺同一份资源

    2.2 取钱

    案例：模拟银行取钱

    其中sleep可以放大问题的发生性

    1. //两个人去银行取钱
    2. public class UnsafeBank {
    3.     public static void main(String[] args) {
    4.         Accout accout = new Accout(100,"结婚基金");
    5.  
    6.         Drawing A = new Drawing(accout,50,"A");
    7.         Drawing B = new Drawing(accout,100,"B");
    8.  
    9.         A.start();
    10.         B.start();
    11.     }
    12. }
    13.  
    14. //账户
    15. class Accout{
    16.     //余额
    17.     int money;
    18.     //卡名字
    19.     String name;
    20.  
    21.     public Accout(int money, String name) {
    22.         this.money = money;
    23.         this.name = name;
    24.     }
    25. }
    26.  
    27. //银行：模拟取款
    28. class Drawing extends Thread{
    29.     //有一个账户
    30.     Accout accout;
    31.     //取了多少钱
    32.     int drawingMoney;
    33.     //现在手里有多少钱
    34.     int nowMoney;
    35.  
    36.     public Drawing(Accout accout,int drawingMoney,String name){
    37.         super(name);
    38.         this.accout=accout;
    39.         this.drawingMoney=drawingMoney;
    40.     }
    41.  
    42.     //取钱
    43.     public void run(){
    44.         //判断有没有钱
    45.         if(accout.money-drawingMoney<0){
    46.             System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
    47.             return;
    48.         }
    49.  
    50.         //模拟延时
    51.         try {
    52.             Thread.sleep(1000);
    53.         } catch (InterruptedException e) {
    54.             e.printStackTrace();
    55.         }
    56.  
    57.         //卡内余额
    58.         accout.money=accout.money-drawingMoney;
    59.         //手里的钱
    60.         nowMoney=nowMoney+drawingMoney;
    61.  
    62.         System.out.println(accout.name+" 余额为："+accout.money);
    63.         //this.getName()=Thread.currentThread().getName()
    64.         System.out.println(this.getName()+" 手里的钱："+nowMoney);
    65.     }
    66. }

    运行结果：线程发生了不安全现象 

    2.3 线程不安全的集合

    案例：模拟ArrayList集合不安全情形

    1. public class UnsafeList {
    2.     public static void main(String[] args) {
    3.         List list = new ArrayList();
    4.         for (int i = 0; i < 1000; i++) {
    5.             //lambda表达式
    6.             new Thread(()->{
    7.                 list.add(Thread.currentThread().getName());
    8.             }).start();
    9.         }
    10.         try {
    11.             Thread.sleep(1000);
    12.         } catch (InterruptedException e) {
    13.             e.printStackTrace();
    14.         }
    15.         System.out.println(list.size());
    16.     }
    17. }

    运行结果：实际容量1000，最后结果为999

    原因：两个线程同一瞬间操作相同的位置（把两个数组添加至同一位置，出现了覆盖）

    三、同步方法及同步块

    3.1 同步方法

     1）由于我们可以通过private关键字来保证数据对象只能被方法访问，所有我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：

            同步方法：public synchronized void method(int args){}

    2）synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行

            缺陷：若将一个大的方法声明为synchronized将会影响效率

     案例：对不安全的买票进行改进

    1. public class UnsafeBuyTicket {
    2.     public static void main(String[] args) {
    3.         BuyTicket buyTicket = new BuyTicket();
    4.  
    5.         new Thread(buyTicket,"A").start();
    6.         new Thread(buyTicket,"B").start();
    7.         new Thread(buyTicket,"C").start();
    8.     }
    9. }
    10.  
    11. class BuyTicket implements Runnable{
    12.     //票
    13.     private int ticketNums = 10;
    14.     //借助外部标志位停止线程
    15.     boolean flag=true;
    16.  
    17.     @Override
    18.     public void run() {
    19.         //买票
    20.         while (flag){
    21.             buy();
    22.         }
    23.     }
    24.  
    25.     //synchronized 同步方法，锁的是this，即这个类本身
    26.     private synchronized void buy(){
    27.         //判断是否有票
    28.         if(ticketNums<=0){
    29.             flag=false;
    30.             return;
    31.         }
    32.         //模拟延时
    33.         try {
    34.             Thread.sleep(100);
    35.         } catch (InterruptedException e) {
    36.             e.printStackTrace();
    37.         }
    38.         //买票
    39.         System.out.println(Thread.currentThread().getName()+" 拿到 "+ticketNums--);
    40.     }
    41. }

     运行结果：解决了多个线程抢夺统一资源的问题

    3.2  同步块

    1)同步块：synchronized(Obj){}

    2)Obj称为同步监视器

            a.Obj可以是任意对象，但是推荐使用共享资源作为同步监视器

            b.同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本                  身，或者是class【反射】

    3）同步监视器的执行过程

            a.第一个线程访问，锁定同步监视器，执行其中代码

            b.第二个线程访问，发现同步监视器被锁定，无法访问

            c.第一个线程执行完毕，解锁同步监视器

            d.第二个线程访问，发现同步监视器没有锁，然后锁定并访问

    4）锁的对象是变化的量（需要增删改）

    案例：修改不安全的取钱

    1. //两个人去银行取钱
    2. public class UnsafeBank {
    3.     public static void main(String[] args) {
    4.         Accout accout = new Accout(100,"结婚基金");
    5.  
    6.         Drawing A = new Drawing(accout,50,"A");
    7.         Drawing B = new Drawing(accout,100,"B");
    8.  
    9.         A.start();
    10.         B.start();
    11.     }
    12. }
    13.  
    14. //账户
    15. class Accout{
    16.     //余额
    17.     int money;
    18.     //卡名字
    19.     String name;
    20.  
    21.     public Accout(int money, String name) {
    22.         this.money = money;
    23.         this.name = name;
    24.     }
    25. }
    26.  
    27. //银行：模拟取款
    28. class Drawing extends Thread{
    29.     //有一个账户
    30.     Accout accout;
    31.     //取了多少钱
    32.     int drawingMoney;
    33.     //现在手里有多少钱
    34.     int nowMoney;
    35.  
    36.     public Drawing(Accout accout,int drawingMoney,String name){
    37.         super(name);
    38.         this.accout=accout;
    39.         this.drawingMoney=drawingMoney;
    40.     }
    41.  
    42.     //取钱
    43.     public void run(){
    44.         synchronized (accout){
    45.             //判断有没有钱
    46.             if(accout.money-drawingMoney<0){
    47.                 System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
    48.                 return;
    49.             }
    50.  
    51.             //模拟延时
    52.             //sleep：可以放大问题的发生性质
    53.             try {
    54.                 Thread.sleep(1000);
    55.             } catch (InterruptedException e) {
    56.                 e.printStackTrace();
    57.             }
    58.  
    59.             //卡内余额
    60.             accout.money=accout.money-drawingMoney;
    61.             //手里的钱
    62.             nowMoney=nowMoney+drawingMoney;
    63.  
    64.             System.out.println(accout.name+" 余额为："+accout.money);
    65.             //this.getName()=Thread.currentThread().getName()
    66.             System.out.println(this.getName()+" 手里的钱："+nowMoney);
    67.         }
    68.  
    69.     }
    70. }

     运行结果：

    同理：修改不安全的集合，只对发生变化的add方法进行同步代码块操作

    1. public class UnsafeList {
    2.     public static void main(String[] args) {
    3.         List list = new ArrayList();
    4.         for (int i = 0; i < 1000; i++) {
    5.             //lambda表达式
    6.             new Thread(()->{
    7.                 synchronized (list){
    8.                     list.add(Thread.currentThread().getName());
    9.                 }
    10.             }).start();
    11.         }
    12.         try {
    13.             Thread.sleep(1000);
    14.         } catch (InterruptedException e) {
    15.             e.printStackTrace();
    16.         }
    17.         System.out.println(list.size());
    18.     }
    19. }

    总结：

    synchronized锁的是类本身

    synchronized锁的是任何东西

    补充：测试JUC安全类的集合，可实现和synchronized同步块一样的效果

    1. public class TestJUC {
    2.     public static void main(String[] args) {
    3.         CopyOnWriteArrayList list=new CopyOnWriteArrayList();
    4.         for (int i = 0; i < 1000; i++) {
    5.             new Thread(()->{
    6.                 list.add(Thread.currentThread().getName());
    7.             }).start();
    8.         }
    9.         try {
    10.             Thread.sleep(1000);
    11.         } catch (InterruptedException e) {
    12.             e.printStackTrace();
    13.         }
    14.         System.out.println(list.size());
    15.     }
    16. }

    四、死锁 

    4.1 什么是死锁

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

    案例：模拟死锁的发生

    1. //多个线程互相抱着对着需要的资源，然后形成僵持
    2. public class DeadLock {
    3.     public static void main(String[] args) {
    4.         Makeup g1 = new Makeup(0,"灰姑娘");
    5.         Makeup g2 = new Makeup(1,"白雪公主");
    6.  
    7.         g1.start();
    8.         g2.start();
    9.     }
    10. }
    11.  
    12. //口红
    13. class Lipstick{
    14.  
    15. }
    16.  
    17. //镜子
    18. class Mirror{
    19.  
    20. }
    21.  
    22. //化妆
    23. class Makeup extends Thread{
    24.     //需要的资源只有一份 --> 用static来保证只有一份
    25.     static Lipstick lipstick=new Lipstick();
    26.     static Mirror mirror=new Mirror();
    27.  
    28.     int choice;//选择
    29.     String girlName;//使用化妆品的人
    30.  
    31.     Makeup(int choice,String girlName){
    32.         this.choice=choice;
    33.         this.girlName=girlName;
    34.     }
    35.  
    36.     @Override
    37.     public void run() {
    38.         //化妆
    39.         try {
    40.             makeup();
    41.         } catch (InterruptedException e) {
    42.             e.printStackTrace();
    43.         }
    44.     }
    45.  
    46.     //化妆：互相持有对方的锁，就是需要拿到对方的资源
    47.     private void makeup() throws InterruptedException {
    48.         if(choice==0){
    49.             //获得口红的锁
    50.             synchronized (lipstick){
    51.                 System.out.println(this.girlName+" 获得口红的锁");
    52.                 Thread.sleep(1000);
    53.  
    54.                 //1秒钟后想获得镜子
    55.                 synchronized (mirror){
    56.                     System.out.println(this.girlName+" 获得镜子的锁");
    57.                 }
    58.             }
    59.         }else{
    60.             synchronized (mirror){
    61.                 System.out.println(this.girlName+" 获得镜子的锁");
    62.                 Thread.sleep(2000);
    63.                 synchronized (lipstick){
    64.                     System.out.println(this.girlName+" 获得口红的锁");
    65.                 }
    66.             }
    67.         }
    68.     }
    69. }

    运行结果：两个线程互相争夺对方的资源，形成僵持 

    改进：不能同时持有对方的锁

    1. //多个线程互相抱着对着需要的资源，然后形成僵持
    2. public class DeadLock {
    3.     public static void main(String[] args) {
    4.         Makeup g1 = new Makeup(0,"灰姑娘");
    5.         Makeup g2 = new Makeup(1,"白雪公主");
    6.  
    7.         g1.start();
    8.         g2.start();
    9.     }
    10. }
    11.  
    12. //口红
    13. class Lipstick{
    14.  
    15. }
    16.  
    17. //镜子
    18. class Mirror{
    19.  
    20. }
    21.  
    22. //化妆
    23. class Makeup extends Thread{
    24.     //需要的资源只有一份 --> 用static来保证只有一份
    25.     static Lipstick lipstick=new Lipstick();
    26.     static Mirror mirror=new Mirror();
    27.  
    28.     int choice;//选择
    29.     String girlName;//使用化妆品的人
    30.  
    31.     Makeup(int choice,String girlName){
    32.         this.choice=choice;
    33.         this.girlName=girlName;
    34.     }
    35.  
    36.     @Override
    37.     public void run() {
    38.         //化妆
    39.         try {
    40.             makeup();
    41.         } catch (InterruptedException e) {
    42.             e.printStackTrace();
    43.         }
    44.     }
    45.  
    46.     //化妆：互相持有对方的锁，就是需要拿到对方的资源
    47.     private void makeup() throws InterruptedException {
    48.         if(choice==0){
    49.             //获得口红的锁
    50.             synchronized (lipstick){
    51.                 System.out.println(this.girlName+" 获得口红的锁");
    52.                 Thread.sleep(1000);
    53.             }
    54.             //1秒钟后想获得镜子
    55.             synchronized (mirror){
    56.                 System.out.println(this.girlName+" 获得镜子的锁");
    57.             }
    58.         }else{
    59.             synchronized (mirror){
    60.                 System.out.println(this.girlName+" 获得镜子的锁");
    61.                 Thread.sleep(2000);
    62.             }
    63.             synchronized (lipstick){
    64.                 System.out.println(this.girlName+" 获得口红的锁");
    65.             }
    66.         }
    67.     }
    68. }

    运行结果：

    4.2 死锁避免方法 

    产生死锁的四个必要条件：

    1）互斥条件：一个资源每次只能被一个进程使用

    2）请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放

    3）不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺

    4）循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

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

    五、Lock（锁）

    1）从JDK5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。

    2）java.util.concurrent.locks.Lock接口时控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源前应先获得Lock对象。

    3）ReentrantLock（可重入锁）类实现了Lock，他拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁

    案例：测试lock锁（基于买票案例）

    1. public class TestLock {
    2.     public static void main(String[] args) {
    3.         TestLock2 testLock2 = new TestLock2();
    4.  
    5.         new Thread(testLock2).start();
    6.         new Thread(testLock2).start();
    7.         new Thread(testLock2).start();
    8.     }
    9. }
    10.  
    11. class TestLock2 implements Runnable{
    12.     int ticketNums = 10;
    13.  
    14.     //定义Lock锁
    15.     private final ReentrantLock lock=new ReentrantLock();
    16.  
    17.     @Override
    18.     public void run() {
    19.         while (true){
    20.             try {
    21.                 //加锁
    22.                 lock.lock();
    23.                 if(ticketNums<=0){
    24.                     break;
    25.                 }else{
    26.                     try {
    27.                         Thread.sleep(1000);
    28.                     } catch (InterruptedException e) {
    29.                         e.printStackTrace();
    30.                     }
    31.                     System.out.println(ticketNums--);
    32.                 }
    33.             }finally {
    34.                 //解锁
    35.                 lock.unlock();
    36.             }
    37.         }
    38.     }
    39. }

    运行结果：

     总结：

     synchronized与Lock的对比：

    1）Lock是显式锁（手动开启和关闭，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放

    2）Lock只有代码块锁，synchronized有代码块锁和方法锁

    3）使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性（提供更多的子类）

    4）优先使用顺序：

            Lock > 同步代码块（已经进入了方法体，分配了相应资源）> 同步方法（在方法体之外）

  • 相关阅读:
    车流量监控系统
    【教程】几种不同的RBF神经网络
    Toronto Research Chemicals 杀菌抗生素丨磷霉素-蔗糖醚二钠盐
    达人评测r9 5900hx和i7 12700h差距 r95900hx和i712700h哪个好
    调整Windows键盘上只能看到拼音而无法看到实际的文本以及关闭输入法悬浮窗方法
    Pulsar-Pulsar 之 pulsar manager
    股票价格跨度
    LVS+Keepalived高可用群集
    OblivSketch: Oblivious Network Measurement as a Cloud Service
    Abnova丨A4GNT多克隆抗体中英文说明
  • 原文地址：https://blog.csdn.net/qq_61727355/article/details/126033544