死锁的形成及解决方法（如何排查死锁）

古城微笑少年丶 2022-01-29 02:53 459阅读 0赞

## 死锁的解决方法 ##

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

**1.安全序列**  
我们首先引入安全序列的定义：所谓系统是安全的，是指系统中的所有进程能够按照某一种次序分配资源，并且依次地运行完毕，这种进程序列\{P1，P2，…，Pn\}就是安全序列。如果存在这样一个安全序列，则系统是安全的；如果系统不存在这样一个安全序列，则系统是不安全的。  
安全序列\{P1，P2，…，Pn\}是这样组成的：若对于每一个进程Pi，它需要的附加资源可以被系统中当前可用资源加上所有进程Pj当前占有资源之和所满足，则\{P1，P2，…，Pn\}为一个安全序列，这时系统处于安全状态，不会进入死锁状态。 　  
虽然存在安全序列时一定不会有死锁发生，但是系统进入不安全状态（四个死锁的必要条件同时发生）也未必会产生死锁。当然，产生死锁后，系统一定处于不安全状态。  
**2.银行家算法**  
这是一个著名的避免死锁的算法，是由Dijstra首先提出来并加以解决的。　  
\[背景知识\]  
一个银行家如何将一定数目的资金安全地借给若干个客户，使这些客户既能借到钱完成要干的事，同时银行家又能收回全部资金而不至于破产，这就是银行家问题。这个问题同操作系统中资源分配问题十分相似：银行家就像一个操作系统，客户就像运行的进程，银行家的资金就是系统的资源。

参考：  
https://blog.csdn.net/caozhao3344/article/details/77199552

## MySQL中的死锁及排查 ##

MySQL中也会产生死锁，同样是竞争资源相互等待。  
比如：  
先查出8,9两行数据，准备进行更新，这时会将8,9两行上锁  
**第一种情况：**

例如（以下会话id为主键）：
     
    Session1:
     
    mysql> select * from t3 where id in (8,9) for update;
    +----+--------+------+---------------------+
    | id | course | name | ctime               |
    +----+--------+------+---------------------+
    |  8 | WA     | f    | 2016-03-02 11:36:30 |
    |  9 | JX     | f    | 2016-03-01 11:36:30 |
    +----+--------+------+---------------------+
    rows in set (0.04 sec)
     
     
    Session2:
    select * from t3 where id in (10,8,5) for update;
    锁等待中……
     
    其实这个时候id=10这条记录没有被锁住的，但id=5的记录已经被锁住了，锁的等待在id=8的这里
    不信请看
     
    Session3:
    mysql> select * from t3 where id=5 for update;
    锁等待中
     
     
    Session4:
    mysql> select * from t3 where id=10 for update;
    +----+--------+------+---------------------+
    | id | course | name | ctime               |
    +----+--------+------+---------------------+
    | 10 | JB     | g    | 2016-03-10 11:45:05 |
    +----+--------+------+---------------------+
    row in set (0.00 sec)
     
     
    在其它session中id=5是加不了锁的，但是id=10是可以加上锁的。

**第二种情况**

以id为主键为例，目前还没有id=22的行
     
    Session1:
    select * from t3 where id=22 for update;
    Empty set (0.00 sec)
     
    session2:
    select * from t3 where id=23  for update;
    Empty set (0.00 sec)
     
    Session1:
    insert into t3 values(22,'ac','a',now());
    锁等待中……
     
    Session2:
    insert into t3 values(23,'bc','b',now());
    ERROR 1213 (40001): Deadlock found when trying to get lock; try restarting transaction

更多情况，见：[MySQL死锁][MySQL]

知道死锁之后，如何进行排查呢？咱也不会啥技巧，就会硬刚。

1.  多打日志看
2.  根据死锁成因分析原因
3.  破坏其中一环即可

## 死锁解决实例： ##

先来看死锁：就是多个锁和多个线程之间发生的故事，这里以俩个锁和俩个线程为例子。

锁1、锁2、线程1、线程2

当线程1获取锁1之后，线程2也获取了锁2，这是线程1又开始获取锁2（嵌套获取），线程2又想获取锁1（嵌套1获取），这种情况下线程1会等着线程2释放锁2，线程2会等着线程1释放锁1，然后就会形成了死锁。

具体代码：

public class deadLock implements Runnable{
     
    	//1.创建俩把锁
    	public static final Object object1=new Object();
    	public static final Object object2=new Object();
    	boolean boo;
    	@Override
    	public void run() {
    		if(boo) {
    			synchronized (object1) {
    				System.out.println("进入1锁");
    				try {
    					Thread.sleep(1000);
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    				synchronized (object2) {
    					System.out.println("进入2锁");
    				}
    			}
    		}else {
    			synchronized(object2) {
    				System.out.println("进入2锁");
    				try {
    					Thread.sleep(1000);
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    				synchronized (object1) {
    					System.out.println("进入1锁");
    				}
    			}
    		}
    		
    	}
    	
    	
    }

测试代码：

public static void main(String[] args) {
    		deadLock d1=new deadLock();
    		deadLock d2=new deadLock();
    		d1.boo=true;
    		d2.boo=false;
    		Thread t1=new Thread(d1);
    		Thread t2=new Thread(d2);
    		t1.start();
    		t2.start();
    	}

怎么解决呢？  
这种解决方式可以有三种，  
1.顺序取锁  
2.设置锁释放时间（可以使用Lock来实现）  
3.预防死锁  
接下来贴出第一个方式的代码：

对比死锁的代码来看，其实就是让所有的线程获取所得顺序是一样的，这样子的话就不会存在什么线程死锁的情况出现。

public class openLock implements Runnable{
    	
    	public static final Object object=new Object();
    	public static final Object object1=new Object();
    	boolean bool;
    	@Override
    	public void run() {
    		if(bool) {
    			synchronized (object) {
    				System.out.println("进入1锁");
    				try {
    					Thread.sleep(1000);
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    				synchronized (object1) {
    					System.out.println("进入二锁");
    				}
    			}
    		}else {
    			synchronized (object) {
    				System.out.println("进入1锁");
    				try {
    					Thread.sleep(1000);
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    				synchronized (object1) {
    					System.out.println("进入2锁");
    				}
    			}
    		}
    		
    	}
    	
    	
    }

第二种方法：

这种方法就是利用Lock来实现的，Lock锁有一种说法叫做可中断锁，意思是当等待的线程达到一定的时间之后，就不会再去等待了，它会放弃运行这个锁方法，而去执行其他方法。

public class OpenLock implements Runnable{
    //第二种解决死锁的方式是：给锁设置一个时间，如果超过这个时间的或就放弃获取这个锁。
    	Lock l1=new ReentrantLock();//锁1
    	Lock l2=new ReentrantLock(); //锁2
    	boolean bool;
    	@Override
    	public void run() {
    		if(bool) {
    			try {
    			l1.lock();
    			System.out.println("加上锁1");
    			try {
    				Thread.sleep(1000);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    			System.out.println("现在我在等待进入锁二了");
    			if(l2.tryLock(200, TimeUnit.MILLISECONDS)){//注意在判断这一步就已经加上锁了
                    try {
                        System.out.println("进入锁二");
                    }finally {
                        l2.unlock();
                    }
                }else{
                    System.out.println("锁二一直被占用，算了我不进去了");
                }
    			
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}finally {
    				l1.unlock();
    			}
    		}else {
    			l2.lock();
    			try {
    				System.out.println("进入锁二");
    				Thread.sleep(1000);
    				System.out.println("现在我在等待进入锁1了");
    				if(l1.tryLock(200,TimeUnit.MILLISECONDS)) {
    					
    					try {
    						System.out.println("进入锁一");
    					}finally {
    						l1.unlock();
    					}
    				}else {
    					System.out.println("等带时间太长了，我不等了。");
    				}
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}finally {
    				
    			}
    		}
    		
    	}
    	
    }

参考：  
https://blog.csdn.net/qq\_38638148/article/details/82725191

[MySQL]: https://blog.csdn.net/tr1912/article/details/81668423