【转载】Java多线程编程2--同步锁定--死锁

悠悠 2022-07-15 05:03 214阅读 0赞

#### 1、死锁实例 ####

Java线程死锁是一个经典的多线程问题，因为不同的线程都在等待根本不可能被释放的锁，从而导致所有的任务都无法继续完成。在多线程技术中，“死锁”是必须避免的，因为这会造成线程的“假死”。

**\[java\]** view plain copy

print ? [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  public class DeathThread implements Runnable \{  
2.      public String username;  
3.      public Object lock1 = new Object();  
4.      public Object lock2 = new Object();  
5.    
6.      public void setFlag(String username) \{  
7.          this.username = username;  
8.      \}  
9.    
10.     public void run() \{  
11.         if (username.equals(“a”)) \{  
12.             synchronized (lock1) \{  
13.                 try \{  
14.                     System.out.println(”username = ” + username);  
15.                     Thread.sleep(2000);  
16.                 \} catch (InterruptedException e) \{  
17.                     e.printStackTrace();  
18.                 \}  
19.   
20.                 synchronized (lock2) \{  
21.                     System.out.println(”按lock1->lock2代码顺序执行了”);  
22.                 \}  
23.             \}  
24.         \}  
25.   
26.         if (username.equals(“b”)) \{  
27.             synchronized (lock2) \{  
28.                 try \{  
29.                     System.out.println(”username = ” + username);  
30.                     Thread.sleep(2000);  
31.                 \} catch (InterruptedException e) \{  
32.                     e.printStackTrace();  
33.                 \}  
34.   
35.                 synchronized (lock1) \{  
36.                     System.out.println(”按lock1->lock2代码顺序执行了”);  
37.                 \}  
38.             \}  
39.         \}  
40.     \}  
41. \}

![save_snippets.png][]

public class DeathThread implements Runnable {
        public String username;
        public Object lock1 = new Object();
        public Object lock2 = new Object();
    
        public void setFlag(String username) {
            this.username = username;
        }
    
        public void run() {
            if (username.equals("a")) {
                synchronized (lock1) {
                    try {
                        System.out.println("username = " + username);
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
    
                    synchronized (lock2) {
                        System.out.println("按lock1->lock2代码顺序执行了");
                    }
                }
            }
    
            if (username.equals("b")) {
                synchronized (lock2) {
                    try {
                        System.out.println("username = " + username);
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
    
                    synchronized (lock1) {
                        System.out.println("按lock1->lock2代码顺序执行了");
                    }
                }
            }
        }
    }

**\[java\]** view plain copy

print ? [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  public class Run \{  
2.      public static void main(String\[\] args) throws InterruptedException \{  
3.          DeathThread deathThread = new DeathThread();  
4.          deathThread.setFlag(”a”);  
5.          Thread thread1 = new Thread(deathThread);  
6.          thread1.start();  
7.          Thread.sleep(1000);  
8.    
9.          deathThread.setFlag(”b”);  
10.         Thread thread2 = new Thread(deathThread);  
11.         thread2.start();  
12.     \}  
13. \}

![save_snippets.png][]

public class Run {
        public static void main(String[] args) throws InterruptedException {
            DeathThread deathThread = new DeathThread();
            deathThread.setFlag("a");
            Thread thread1 = new Thread(deathThread);
            thread1.start();
            Thread.sleep(1000);
    
            deathThread.setFlag("b");
            Thread thread2 = new Thread(deathThread);
            thread2.start();
        }
    }

<table> 
 <tbody> 
  <tr> 
   <td>username = a<br> username = b</td> 
  </tr> 
 </tbody> 
</table>

出现死锁

死锁是程序设计的Bug.在设计程序时就要避免双方互相持有对方的锁的情况。需要说明的是，本实验使用synchronized嵌套的代码结构来实现死锁，其实不使用嵌套的synchronized代码结构也会出现死锁，与嵌套不嵌套无任何的关系，不要被代码结构所误导。

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

[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/1671939
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/1671939/fork
[save_snippets.png]: /images/20220715/f1974f7cce224d019abff34edc81966d.png