死锁是什么样的?

a b两个锁嵌套在两个方法中，第一个方法中a锁嵌套b锁，第二个方法中b锁嵌套a锁，

1. /*
   
2. * 死锁： 多个线程之间，相互访问
   
3. */
   
4. public class LockDemo {
   
5.         public static void main(String[] args) {
   
6.                 //创建2个线程对象
   
7.                 MyLock m1 = new MyLock();
   
8.                 MyLock m2 = new MyLock();
   
9.                
   
10.                 //启动线程
    
11.                 m1.start();
    
12.                 m2.start();
    
13.         }
    
14. }

复制代码

1. 
   
2. public class MyLock extends Thread {
   
3. 
   
4.         private int x = 0;
   
5. 
   
6.         @Override
   
7.         public void run() {
   
8.                 //m1,m2
   
9.                
   
10.                
    
11.                 while(true){
    
12.                        
    
13.                         //m1,m2
    
14.                        
    
15.                         if (x % 2 == 0) {
    
16.                                
    
17.                                 //第一个人   m1
    
18.                                 synchronized (MeLock.objA) {
    
19.                                         System.out.println("objA--(if)");
    
20.                                        
    
21.                                         //模拟抢第二个人的筷子
    
22.                                         synchronized (MeLock.objB) {
    
23.                                                 System.out.println("objB---(if)");
    
24.                                         }
    
25.                                 }
    
26.                                
    
27.                                
    
28.                         } else {
    
29.                                        
    
30.                                 //另一个人
    
31.                                 synchronized (MeLock.objB) {
    
32.                                         System.out.println("objB---(else)");
    
33.                                        
    
34.                                         //原来的第一个人  又想吃
    
35.                                        
    
36.                                         //模拟抢第一个人的筷子
    
37.                                         synchronized (MeLock.objA) {
    
38.                                                 System.out.println("objA---(else)");
    
39.                                         }
    
40.                                 }
    
41.                         }
    
42.                        
    
43.                         x++;
    
44.                 }
    
45.         }
    
46. }

复制代码

1. /*
   
2. *        锁对象
   
3. */
   
4. public class MeLock {
   
5.         public static Object objA = new Object();
   
6.         public static Object objB = new Object();
   
7. }

复制代码

死锁的例子

互相争夺资源　　　导致两者都进行不下去

所谓死锁： 是指两个或两个以上的线程在执行过程中，因争夺资源而造成的一种互相等待的现象。

就是两个线程， 你拿着我的锁不给我， 我拿着你的索不给你， 这样咱们都别开门了