• 深入理解多线程（第二篇）

     ✅作者简介：大家好我是@每天都要敲代码，一位材料转码农的选手，希望一起努力，一起进步！
    📃个人主页：@每天都要敲代码的个人主页

    🔥系列专栏：JavaSE从入门到精通
    💬推荐一款模拟面试、刷题神器，从基础到大厂面试题👉点击跳转刷题网站进行注册学习

    目录

    一：线程安全（很重要）

    1.模拟两个线程对同一个银行账户取款（不使用线程同步）

    二：使用线程同步机制（synchronized）

    1.模拟两个线程对同一个银行账户取款（使用线程同步）

    2.sychronized的理解 

    3.那些变量有线程安全问题

    4.sychronized出现在实例方法上

    5.总结synchronized的三种写法： 

    6.死锁概述

    7.开发中怎么解决线程安全问题

    结束语

    一：线程安全（很重要）

    关于多线程并发环境下，数据的安全问题：

    1、为什么这个线程安全是重点？
          在以后在开发中，我们的项目都是运行在服务器当中，而服务器已经将线程的定义，线程对象的创建，启动等，都已经实现完了。这些代码我们都不需要编写。

          最重要的是：我们要知道，你编写的程序需要放到一个多线程的环境下运行，你更需要关注的是这些数据在多线程并发的环境下是否是安全的

          我们举个生活中的简单例子：线程并发对同一个账户取款。我和小鹏同时去取款，我是把钱取出来，如果因为数据延迟，没有及时更新账户；此时小鹏再去取款也取出来了，这就会造成数据的不安全！


    2、什么时候数据在多线程并发的环境下会存在安全问题？
                条件1：多线程并发。
                条件2：有共享数据。
                条件3：共享数据有修改的行为

            满足以上3个条件之后，就会存在线程安全问题。   
    3、怎么解决线程安全问题？线程同步机制
            当多线程并发的环境下，有共享数据，并且这个数据还会被修改，此时就存在线程安全问题，怎么解决这个问题？
            线程排队执行（不能并发）；用排队执行解决线程安全问题；这种机制被称为：线程同步机制。专业术语叫做：线程同步，实际上就是线程不能并发了，线程必须排队执行！   
            线程同步就是线程排队了，线程排队了就会牺牲一部分效率，数据安全第一位，只有数据安全了，我们才可以谈效率。   
    4、说到线程同步这块，涉及到这两个专业术语：

            异步编程模型：线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，谁也不需要等谁，这种编程模型叫做：异步编程模型。其实就是：多线程并发（效率较高）

            同步编程模型：线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行结束，或者说在t2线程执行的时候，必须等待t1线程执行结束，两个线程之间发生了等待关系，这就是同步编程模型。效率较低。线程排队执行。

    总结： 异步就是并发； 同步就是排队！

    1.模拟两个线程对同一个银行账户取款（不使用线程同步）

    1、Account账户类

    1. package com.bjpowernode.java.threadsafe;
    2. // 银行账户
    3. public class Account {
    4.     // 账号
    5.     private String actno;
    6.     // 余额
    7.     private double balance;
    8.  
    9.     // 构造方法
    10.     public Account() {
    11.     }
    12.     public Account(String actno, double balance) {
    13.         this.actno = actno;
    14.         this.balance = balance;
    15.     }
    16.  
    17.     // setter and getter
    18.     public String getActno() {
    19.         return actno;
    20.     }
    21.     public void setActno(String actno) {
    22.         this.actno = actno;
    23.     }
    24.     public double getBalance() {
    25.         return balance;
    26.     }
    27.     public void setBalance(double balance) {
    28.         this.balance = balance;
    29.     }
    30.  
    31.     // 取款方法
    32.     public void withdraw(double money){
    33.         // 取款之前的余额
    34.         double before = this.getBalance();
    35.         // 取款之后的余额
    36.         double after = before - money;
    37.         // 更新余额
    38.         this.setBalance(after);
    39.  
    40.     }
    41.  
    42. }

    2、两个线程对同一个账户取款

    1. package com.bjpowernode.java.threadsafe;
    2.  
    3. public class AccountThread extends Thread{
    4.     // 保证两个线程共享一个账户对象
    5.     private Account act;
    6.     // 通过构造方法传递过来账户对象
    7.     public AccountThread(Account act) {
    8.         this.act = act;
    9.     }
    10.       public void run() {
    11.         // 假设取款5000
    12.         double money = 5000;
    13.         // 取款
    14.         // 多线程并发执行这个方法
    15.         act.withdraw(money);
    16.         System.out.println(Thread.currentThread().getName()+"对"+"账户"+act.getActno()+"取款成功，余额"+act.getBalance());
    17.     }
    18. }

    3、测试

    1. package com.bjpowernode.java.threadsafe;
    2.  
    3. public class Test {
    4.     public static void main(String[] args) {
    5.         // 创建对象
    6.         Account act = new Account("act---1",10000);
    7.         // 创建两个线程
    8.         Thread t1 = new AccountThread(act);
    9.         Thread t2 = new AccountThread(act);
    10.         // 设置线程名字
    11.         t1.setName("t1");
    12.         t2.setName("t2");
    13.         // 启动线程
    14.         t1.start();
    15.         t2.start();
    16.     }
    17. }
    18. /*
    19. t1对账户act---1取款成功，余额5000.0
    20. t2对账户act---1取款成功，余额5000.0
    21. */

    二：使用线程同步机制（synchronized）

    1、线程同步机制的语法是：

    1.     synchronized(){
    2.                 // 线程同步代码块。
    3.             }

    synchronized后面小括号中传的这个“数据”是相当关键的；这个数据必须是多线程共享的数据；才能达到多线程排队！

    2、()中写什么？
        （1）要看你想让哪些线程同步；假设t1、t2、t3、t4、t5，有5个线程；你只希望t1 t2 t3排队，t4 t5不需要排队。怎么办？你一定要在()中写一个t1 t2 t3共享的对象。而这个对象对于t4 t5来说不是共享的。

        （2）这里的共享对象是：账户对象；账户对象是共享的，那么this就是账户对象吧！当然不一定是this，这里只要是多线程共享的那个对象就行

        （3）在java语言中，任何一个对象都有“一把锁”，其实这把锁就是标记！
    ；100个对象，100把锁。1个对象1把锁。对于锁的理解：相当于我们去上厕所，把门锁上，别人进不来；等解决了，打开锁别人才能进来！

    3、以下代码的执行原理？
       （1）假设t1和t2线程并发，开始执行以下代码的时候，肯定有一个先一个后。
       （2）假设t1先执行了，遇到了synchronized，这个时候自动找“后面共享对象”的对象锁，找到之后，并占有这把锁，然后执行同步代码块中的程序，在程序执行过程中一直都是占有这把锁的。直到同步代码块代码结束，这把锁才会释放。
       （3）假设t1已经占有这把锁，此时t2也遇到synchronized关键字，也会去占有后面共享对象的这把锁，结果这把锁被t1占有，t2只能在同步代码块外面等待t1的结束，直到t1把同步代码块执行结束了，t1会归还这把锁，此时t2终于等到这把锁，然后t2占有这把锁之后，进入同步代码块执行程序。这样就达到了线程排队执行。
    注意：这个共享对象一定要选好了；这个共享对象一定是你需要排队执行的这些线程对象所共享的！

    1.模拟两个线程对同一个银行账户取款（使用线程同步）

    1. package com.bjpowernode.java.Threadsafe2;
    2. // 使用线程同步，解决线程安全问题
    3.  
    4. // 银行账户
    5. public class Account {
    6.     // 账号
    7.     private String actno;
    8.     // 余额
    9.     private double balance;
    10.  
    11.     // 构造方法
    12.     public Account() {
    13.     }
    14.     public Account(String actno, double balance) {
    15.         this.actno = actno;
    16.         this.balance = balance;
    17.     }
    18.  
    19.     // setter and getter
    20.     public String getActno() {
    21.         return actno;
    22.     }
    23.     public void setActno(String actno) {
    24.         this.actno = actno;
    25.     }
    26.     public double getBalance() {
    27.         return balance;
    28.     }
    29.     public void setBalance(double balance) {
    30.         this.balance = balance;
    31.     }
    32.  
    33.     // 取款方法，t1和t2并发这个方法
    34.     // t1和t2是两个栈，两个栈操作堆中同一个对象
    35.     public void withdraw(double money){
    36.         // 以下这几行代码必须是线程排队的，不能并发。
    37.         // 一个线程把这里的代码全部执行结束之后，另一个线程才能进来。
    38.         // 线程同步机制，线程同步执行
    39.         // this就是指当前共享的对象Account账户
    40.         synchronized (this){
    41.             double before = this.getBalance();
    42.             double after = before - money;
    43.             try {
    44.                 Thread.sleep(1000);
    45.             } catch (InterruptedException e) {
    46.                 e.printStackTrace();
    47.             }
    48.  
    49.             this.setBalance(after);
    50.         }
    51.  
    52.     }
    53.  
    54. }
    55. /*
    56. t1对账户act---1取款5000.0成功，余额5000.0
    57. t2对账户act---1取款5000.0成功，余额0.0
    58. */

    2.sychronized的理解 

    2.1 不写this写其它的一个共享的对象；这里写this和“abc”是没区别的

    1. package com.bjpowernode.java.threadsafe2;
    2. /*
    3. 银行账户
    4.     使用线程同步机制，解决线程安全问题。
    5.  */
    6. public class Account {
    7.     // 账号
    8.     private String actno;
    9.     // 余额
    10.     private double balance; //实例变量。
    11.  
    12.     //对象
    13.     Object obj = new Object(); // 实例变量。
    14.    //（Account对象是多线程共享的，Account对象中的实例变量obj也是共享的。）
    15.  
    16.     public Account() {
    17.     }
    18.  
    19.     public Account(String actno, double balance) {
    20.         this.actno = actno;
    21.         this.balance = balance;
    22.     }
    23.  
    24.     public String getActno() {
    25.         return actno;
    26.     }
    27.  
    28.     public void setActno(String actno) {
    29.         this.actno = actno;
    30.     }
    31.  
    32.     public double getBalance() {
    33.         return balance;
    34.     }
    35.  
    36.     public void setBalance(double balance) {
    37.         this.balance = balance;
    38.     }
    39.  
    40.     //取款的方法
    41.     public void withdraw(double money){
    42.  
    43.         //int i = 100;
    44.         //i = 101;
    45.  
    46.         // 以下这几行代码必须是线程排队的，不能并发。
    47.         // 一个线程把这里的代码全部执行结束之后，另一个线程才能进来。
    48.        
    49.         //Object obj2 = new Object();
    50.          synchronized (this){ // 只要是一个共享对象就行
    51.         //synchronized (obj) { // 实例变量，Account对象是共享的，它的实例对象也可以
    52.         //synchronized ("abc") { // "abc"在字符串常量池当中；写"abc"所有线程都会同步
    53.         //synchronized (null) { // 报错：空指针。
    54.         //synchronized (obj2) { // 局部变量。因为obj2不是共享对象；每次调用都会new
    55.             double before = this.getBalance();
    56.             double after = before - money;
    57.             try {
    58.                 Thread.sleep(1000);
    59.             } catch (InterruptedException e) {
    60.                 e.printStackTrace();
    61.             }
    62.             this.setBalance(after);
    63.         //}
    64.     }
    65. }

    2.2 如果修改下面代码，就不同了；this表示t1和t2是线程同步的，和t3没有关系；如果写"abc"那就是t1,t2,t3都是线程同步的

    1. package com.bjpowernode.java.threadsafe2;
    2.  
    3. public class Test {
    4.     public static void main(String[] args) {
    5.         // 创建账户对象（只创建1个）
    6.         Account act = new Account("act-001", 10000);
    7.         // 创建两个线程
    8.         Thread t1 = new AccountThread(act);
    9.         Thread t2 = new AccountThread(act);
    10.         // 又new对象，创建一个线程
    11. 		Account act2 = new Account("act-001", 10000);
    12. 		Thread t3 = new AccountThread(act2);
    13.         // 设置name
    14.         t1.setName("t1");
    15.         t2.setName("t2");
    16.         // 启动线程取款
    17.         t1.start();
    18.         t2.start();
    19.     }
    20. }

    2.3 扩大同步范围

    1. package com.bjpowernode.java.Threadsafe2;
    2.  
    3. public class AccountThread extends Thread{
    4.     // 保证两个线程共享一个账户对象
    5.     private Account act;
    6.     // 通过构造方法传递过来账户对象
    7.     public AccountThread(Account act) {
    8.         this.act = act;
    9.     }
    10.       public void run() {
    11.         // 假设取款5000
    12.         double money = 5000;
    13.         // 取款
    14.         // 多线程并发执行这个方法
    15.  
    16.         synchronized(act){ 
    17.         // 共享对象是act，不能写this，this代表的是线程对象AccountThread，线程对象我们new了两个
    18.             act.withdraw(money); // 在这里加synchronized，扩大了同步范围
    19.         }
    20.         
    21.         System.out.println(Thread.currentThread().getName()+"对"+"账户"+act.getActno()+"取款"+money+"成功，余额"+act.getBalance());
    22.     }
    23. }

    3.那些变量有线程安全问题

    1、Java中有三大变量【重要的内容】

        实例变量：在堆中

        静态变量：在方法区

        局部变量：在栈中

    2、以上三大变量中：

        （1）局部变量永远都不会存在线程安全问题！因为局部变量不共享。（一个线程一个栈）局部变量在栈中。所以局部变量永远都不会共享。
        （2）实例变量在堆中，堆只有1个。
        （3）静态变量在方法区中，方法区只有1个。

    3、堆和方法区都是多线程共享的，所以可能存在线程安全问题

        局部变量+常量：不会有线程安全问题。
        成员变量：可能会有线程安全问题。（实例变量+静态变量）

    4.sychronized出现在实例方法上

    1、在实例方法上可以使用synchronized吗？可以的。
    （1）synchronized出现在实例方法上，一定锁的是this；没得挑。只能是this。不能是其他的对象了。 所以这种方式不灵活。

    （2）另外还有一个缺点：synchronized出现在实例方法上，表示整个方法体都需要同步，可能会无故扩大同步的范围，导致程序的执行效率降低。所以这种方式不常用。

    public synchronized void withdraw(double money){}

    （3）synchronized使用在实例方法上有什么优点：代码写的少了。节俭了。

    （4）如果共享的对象就是this，并且需要同步的代码块是整个方法体，建议使用这种方式。

    1. package com.bjpowernode.java.threadsafe3;
    2. // 不使用线程同步机制，多线程对同一个账户进行取款，出现线程安全问题
    3.  
    4. // 银行账户
    5. public class Account {
    6.     // 账号
    7.     private String actno;
    8.     // 余额
    9.     private double balance;
    10.  
    11.     // 构造方法
    12.     public Account() {
    13.     }
    14.     public Account(String actno, double balance) {
    15.         this.actno = actno;
    16.         this.balance = balance;
    17.     }
    18.  
    19.     // setter and getter
    20.     public String getActno() {
    21.         return actno;
    22.     }
    23.     public void setActno(String actno) {
    24.         this.actno = actno;
    25.     }
    26.     public double getBalance() {
    27.         return balance;
    28.     }
    29.     public void setBalance(double balance) {
    30.         this.balance = balance;
    31.     }
    32.  
    33.     // 取款的方法
    34.  
    35.     public synchronized  void withdraw(double money){
    36.         double before = this.getBalance();
    37.         double after = before - money;
    38.         try {
    39.             Thread.sleep(1000);
    40.         } catch (InterruptedException e) {
    41.             e.printStackTrace();
    42.         }
    43.  
    44.         this.setBalance(after);
    45.  
    46.     }
    47.  
    48. }

    5.总结synchronized的三种写法： 

    第一种：同步代码块，比较灵活

    1.   synchronized(线程共享对象){
    2.                 同步代码块;
    3.             }

    第二种：在实例方法上使用synchronized，表示共享对象一定是this，并且同步代码块是整个方法体。

      public synchronized  void withdraw(double money){}

    第三种：在静态方法上使用synchronized表示找类锁，类锁永远只有1把。

                  就算创建了100个对象，那类锁也只有一把！
            
    对象锁：1个对象1把锁，100个对象100把锁！
    类锁：100个对象，也可能只是1把类锁！

    synchronized面试题1：

    面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
    答：不需要，doSome执行时候会把这把锁占着，但是doOther()方法没有synchronized，不需要占用锁，直接就能执行

    1. package com.bjpowernode.java.exam;
    2.  
    3. public class Exam01 {
    4.     public static void main(String[] args) {
    5.         MyClass mc = new MyClass();
    6.         Thread t1 = new MyThread(mc);
    7.         Thread t2 = new MyThread(mc);
    8.         t1.setName("t1");
    9.         t2.setName("t2");
    10.  
    11.         t1.start();
    12.         try {
    13.             Thread.sleep(1000); //这个睡眠的作用：为了保证t1线程先执行
    14.         } catch (InterruptedException e) {
    15.             e.printStackTrace();
    16.         }
    17.         t2.start();
    18.  
    19.  
    20.     }
    21. }
    22.  
    23. // 线程
    24. class MyThread extends Thread{
    25.     private MyClass mc;
    26.     public MyThread(MyClass mc) {
    27.         this.mc = mc;
    28.     }
    29.  
    30.     public void run() {
    31.         if(Thread.currentThread().getName().equals("t1")){
    32.             mc.doSome();
    33.         }
    34.         if(Thread.currentThread().getName().equals(("t2"))){
    35.             mc.doOther();
    36.         }
    37.     }
    38. }
    39.  
    40. class MyClass {
    41.  
    42.     // doSome方法有synchronized，锁的是当前对象MyClass
    43.     public synchronized void doSome(){
    44.         System.out.println("doSome begin");
    45.         try {
    46.             Thread.sleep(1000 * 10);
    47.         } catch (InterruptedException e) {
    48.             e.printStackTrace();
    49.         }
    50.         System.out.println("doSome over");
    51.     }
    52.  
    53.     // doOther方法没有synchronized
    54.     public void doOther(){
    55.         System.out.println("doOther begin");
    56.         System.out.println("doOther over");
    57.     }
    58. }
    59. /* 执行结果：
    60.     doSome begin
    61.     doOther begin
    62.     doOther over
    63.     doSome over
    64. */

    synchronized面试题2：

    面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
    答：需要，doSome执行时候会把这把锁占着，doOther()方法里也有synchronized，也需要占用这把锁去执行，所以需要等待doSome执行结束

    1. package com.bjpowernode.java.exam;
    2.  
    3. public class Exam01 {
    4.     public static void main(String[] args) {
    5.         MyClass mc = new MyClass();
    6.         Thread t1 = new MyThread(mc);
    7.         Thread t2 = new MyThread(mc);
    8.         t1.setName("t1");
    9.         t2.setName("t2");
    10.  
    11.         t1.start();
    12.         try {
    13.             Thread.sleep(1000); //这个睡眠的作用：为了保证t1线程先执行
    14.         } catch (InterruptedException e) {
    15.             e.printStackTrace();
    16.         }
    17.         t2.start();
    18.  
    19.  
    20.     }
    21. }
    22.  
    23. // 线程
    24. class MyThread extends Thread{
    25.     private MyClass mc;
    26.     public MyThread(MyClass mc) {
    27.         this.mc = mc;
    28.     }
    29.  
    30.     public void run() {
    31.         if(Thread.currentThread().getName().equals("t1")){
    32.             mc.doSome();
    33.         }
    34.         if(Thread.currentThread().getName().equals(("t2"))){
    35.             mc.doOther();
    36.         }
    37.     }
    38. }
    39.  
    40. class MyClass {
    41.  
    42.     // doSome方法有synchronized，锁的是当前对象MyClass
    43.     public synchronized void doSome(){
    44.         System.out.println("doSome begin");
    45.         try {
    46.             Thread.sleep(1000 * 10);
    47.         } catch (InterruptedException e) {
    48.             e.printStackTrace();
    49.         }
    50.         System.out.println("doSome over");
    51.     }
    52.  
    53.     // doOther方法也有synchronized
    54.     public synchronized void doOther(){
    55.         System.out.println("doOther begin");
    56.         System.out.println("doOther over");
    57.     }
    58. }
    59. /* 执行结果：
    60.     doSome begin
    61.     doSome over
    62.     doOther begin
    63.     doOther over
    64. */

    synchronized面试题3：

    面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
    答：不需要，doSome方法锁的是mc1对象，doSome方法锁的是mc2对象，这里是两把锁

    1. package com.bjpowernode.java.exam03;
    2.  
    3. public class Exam02 {
    4.     public static void main(String[] args) {
    5.         // 创建了两个对象
    6.         MyClass mc1 = new MyClass();
    7.         MyClass mc2 = new MyClass();
    8.  
    9.         Thread t1 = new MyThread(mc1);
    10.         Thread t2 = new MyThread(mc2);
    11.         t1.setName("t1");
    12.         t2.setName("t2");
    13.  
    14.         t1.start();
    15.         try {
    16.             Thread.sleep(1000); //这个睡眠的作用：为了保证t1线程先执行
    17.         } catch (InterruptedException e) {
    18.             e.printStackTrace();
    19.         }
    20.         t2.start();
    21.  
    22.  
    23.     }
    24. }
    25.  
    26. // 线程
    27. class MyThread extends Thread{
    28.     private MyClass mc;
    29.     public MyThread(MyClass mc) {
    30.         this.mc = mc;
    31.     }
    32.  
    33.     public void run() {
    34.         if(Thread.currentThread().getName().equals("t1")){
    35.             mc.doSome();
    36.         }
    37.         if(Thread.currentThread().getName().equals(("t2"))){
    38.             mc.doOther();
    39.         }
    40.     }
    41. }
    42.  
    43. class MyClass {
    44.  
    45.     // doSome方法有synchronized，锁的是当前对象MyClass
    46.     public synchronized void doSome(){
    47.         System.out.println("doSome begin");
    48.         try {
    49.             Thread.sleep(1000 * 10);
    50.         } catch (InterruptedException e) {
    51.             e.printStackTrace();
    52.         }
    53.         System.out.println("doSome over");
    54.     }
    55.  
    56.     // doOther方法也有synchronized
    57.     public synchronized void doOther(){
    58.         System.out.println("doOther begin");
    59.         System.out.println("doOther over");
    60.     }
    61. }
    62. /* 执行结果：
    63.     doSome begin
    64.     doOther begin
    65.     doOther over
    66.     doSome over
    68. */

    synchronized面试题4：

    面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
    答：都改成静态方法，synchronized出现在静态方法上是找类锁；需要，因为静态方法是类锁，不管创建了几个对象，类锁只有1把！

    1. package com.bjpowernode.java.exam04;
    2.  
    3.  
    4. public class Exam02 {
    5.     public static void main(String[] args) {
    6.         MyClass mc1 = new MyClass();
    7.         MyClass mc2 = new MyClass();
    8.  
    9.         Thread t1 = new MyThread(mc1);
    10.         Thread t2 = new MyThread(mc2);
    11.         t1.setName("t1");
    12.         t2.setName("t2");
    13.  
    14.         t1.start();
    15.         try {
    16.             Thread.sleep(1000); //这个睡眠的作用：为了保证t1线程先执行
    17.         } catch (InterruptedException e) {
    18.             e.printStackTrace();
    19.         }
    20.         t2.start();
    21.  
    22.  
    23.     }
    24. }
    25.  
    26. // 线程
    27. class MyThread extends Thread{
    28.     private MyClass mc;
    29.     public MyThread(MyClass mc) {
    30.         this.mc = mc;
    31.     }
    32.  
    33.     public void run() {
    34.         if(Thread.currentThread().getName().equals("t1")){
    35.             mc.doSome();
    36.         }
    37.         if(Thread.currentThread().getName().equals(("t2"))){
    38.             mc.doOther();
    39.         }
    40.     }
    41. }
    42.  
    43. class MyClass {
    44.  
    45.     // doSome方法有synchronized，锁的是当前对象MyClass
    46.     public synchronized static void doSome(){
    47.         System.out.println("doSome begin");
    48.         try {
    49.             Thread.sleep(1000 * 10);
    50.         } catch (InterruptedException e) {
    51.             e.printStackTrace();
    52.         }
    53.         System.out.println("doSome over");
    54.     }
    55.  
    56.     // doOther方法也有synchronized
    57.     public synchronized static void doOther(){
    58.         System.out.println("doOther begin");
    59.         System.out.println("doOther over");
    60.     }
    61. }
    62. /* 执行结果：
    63.     doSome begin
    64.     doSome over
    65.     doOther begin
    66.     doOther over
    68. */

    6.死锁概述

    假设有两个线程，T1是从上往下执行，T2对象是从下往上执行；T1先锁了上面一个对象，T2先锁住了下面一个对象；这就造成T1锁下面对象锁不了，T2锁上面对象锁不了；这样代码都不会执行结束，也就不会释放锁；不会出现异常，也不会出现错误，程序一直僵持在那里！

    1. package com.bjpowernode.java.deadlock;
    2. // 要会写死锁代码
    3. public class DeadLock {
    4.     public static void main(String[] args) {
    5.         Object o1 = new Object();
    6.         Object o2 = new Object();
    7.  
    8.         Thread t1 = new MyThread1(o1,o2);
    9.         Thread t2 = new MyThread2(o1,o2);
    10.  
    11.         t1.start();
    12.         t2.start();
    13.     }
    14. }
    15.  
    16. class MyThread1 extends Thread{
    17.     Object o1;
    18.     Object o2;
    19.  
    20.     public MyThread1(Object o1, Object o2) {
    21.         this.o1 = o1;
    22.         this.o2 = o2;
    23.     }
    24.  
    25.     public void run() {
    26.         // 先锁o1，在锁o2
    27.         synchronized (o1){
    28.             try {
    29.                 Thread.sleep(1000);
    30.             } catch (InterruptedException e) {
    31.                 e.printStackTrace();
    32.             }
    33.             synchronized (o2){
    34.  
    35.             }
    36.         }
    37.  
    38.  
    39.     }
    40. }
    41.  
    42. class MyThread2 extends Thread{
    43.     Object o1;
    44.     Object o2;
    45.  
    46.     public MyThread2(Object o1, Object o2) {
    47.         this.o1 = o1;
    48.         this.o2 = o2;
    49.     }
    50.  
    51.     public void run() {
    52.         // 先锁o2，在锁o1
    53.         synchronized (o2){
    54.             try {
    55.                 Thread.sleep(1000);
    56.             } catch (InterruptedException e) {
    57.                 e.printStackTrace();
    58.             }
    59.             synchronized (o1){
    60.  
    61.             }
    62.         }
    63.  
    64.     }
    65. }

    7.开发中怎么解决线程安全问题

    （1）是一上来就选择线程同步吗？synchronized
        不是，synchronized会让程序的执行效率降低，用户体验不好；系统的用户吞吐量降低。用户体验差。在不得已的情况下再选择线程同步机制。
    （2）第一种方案：尽量使用局部变量代替“实例变量和静态变量”。

    （3）第二种方案：如果必须是实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了。（一个线程对应1个对象，100个线程对应100个对象，对象不共享，就没有数据安全问题了）

    （4）第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候就只能选择synchronized了。线程同步机制。

    结束语

    今天的分享就到这里啦！快快通过下方链接注册加入刷题大军吧！各种大厂面试真题在等你哦！
    💬刷题神器，从基础到大厂面试题👉点击跳转刷题网站进行注册学习

     

  • 相关阅读:
    能碳双控| AIRIOT智慧能碳管理解决方案
    Spring Retry方法重试
    pandas read_json时ValueError: Expected object or value的解决方案
    Python 中国象棋游戏【含Python源码 MX_011期】
    8款常见的自动化测试开源框架
    YOLO物体检测系列3：YOLOV3改进解读
    【Vue CLI】
    Python 中格式化字符串及 format 函数用法
    shell的for循环与结构化
    C语言——有一篇文章，共有 3 行文字，每行有 80 个字符。要求分别统计出其中英文大写字母、小写字母、数字、空格以及其他字符的个数
  • 原文地址：https://blog.csdn.net/m0_61933976/article/details/126226824