JAVA并发-3种典型的死锁

在JAVA并发编程中，我们使用锁来确保可变共享变量的安全性。要注意的是，不正确的使用锁很容易导致死锁。

死锁的4个必要条件：
1. 互斥访问
2. 非抢占
3. 持有并等待
4. 循环等待

在JAVA编程中，有3种典型的死锁类型：
静态的锁顺序死锁，动态的锁顺序死锁，协作对象之间发生的死锁。

静态的锁顺序死锁：
a和b两个方法都需要获得A锁和B锁。一个线程执行a方法且已经获得了A锁，在等待B锁；另一个线程执行了b方法且已经获得了B锁，在等待A锁。这种状态，就是发生了静态的锁顺序死锁。

//可能发生静态锁顺序死锁的代码
class StaticLockOrderDeadLock{
	private final Object lockA=new Object();
	private final Object lockB=new Object();
	public void a(){
		synchronized (lockA) {
			synchronized (lockB) {
				System.out.println("function a");
			}
		}
	}
	
	public void b(){
		synchronized (lockB) {
			synchronized (lockA) {
				System.out.println("function b");
			}
		}
	}
}

解决静态的锁顺序死锁的方法就是：所有需要多个锁的线程，都要以相同的顺序来获得锁。

 

//正确的代码
class StaticLockOrderDeadLock{
	private final Object lockA=new Object();
	private final Object lockB=new Object();
	public void a(){
		synchronized (lockA) {
			synchronized (lockB) {
				System.out.println("function a");
			}
		}
	}
	
	public void b(){
		synchronized (lockA) {
			synchronized (lockB) {
				System.out.println("function b");
			}
		}
	}
}

动态的锁顺序死锁：
动态的锁顺序死锁是指两个线程调用同一个方法时，传入的参数颠倒造成的死锁。如下代码，一个线程调用了transferMoney方法并传入参数accountA,accountB；另一个线程调用了transferMoney方法并传入参数accountB,accountA。此时就可能发生在静态的锁顺序死锁中存在的问题，即：第一个线程获得了accountA锁并等待accountB锁，第二个线程获得了accountB锁并等待accountA锁。

 

//可能发生动态锁顺序死锁的代码
class DynamicLockOrderDeadLock{
	public void transefMoney(Account fromAccount,Account toAccount,Double amount){
		synchronized (fromAccount) {
			synchronized (toAccount) {
				//...
				fromAccount.minus(amount);
				toAccount.add(amount);
				//...
			}
		}
	}
}

动态的锁顺序死锁解决方案如下：使用System.identifyHashCode来定义锁的顺序。确保所有的线程都以相同的顺序获得锁

 

//正确的代码
class DynamicLockOrderDeadLock{
	private final Object myLock=new Object();
	public void transefMoney(final Account fromAccount,final Account toAccount,final Double amount){
		class Helper{
			public void transfer(){
				//...
				fromAccount.minus(amount);
				toAccount.add(amount);
				//...
			}
		}
		int  fromHash=System.identityHashCode(fromAccount);
		int  toHash=System.identityHashCode(toAccount);
		
		if(fromHash<toHash){
			synchronized (fromAccount) {
				synchronized (toAccount) {
					new Helper().transfer();
				}
			}
		}else if(fromHash>toHash){
			synchronized (toAccount) {
				synchronized (fromAccount) {
					new Helper().transfer();
				}
			}
		}else{
			synchronized (myLock) {
				synchronized (fromAccount) {
					synchronized (toAccount) {
						new Helper().transfer();
					}
				}
			}
		}
		
	}
}

协作对象之间发生的死锁：
有时，死锁并不会那么明显，比如两个相互协作的类之间的死锁，比如下面的代码：一个线程调用了Taxi对象的setLocation方法，另一个线程调用了Dispatcher对象的getImage方法。此时可能会发生，第一个线程持有Taxi对象锁并等待Dispatcher对象锁，另一个线程持有Dispatcher对象锁并等待Taxi对象锁。

 

//可能发生死锁
class Taxi{
	private Point location,destination;
	private final Dispatcher dispatcher;
	public Taxi(Dispatcher dispatcher) {
		this.dispatcher=dispatcher;
	}
	public synchronized Point getLocation(){
		return location;
	}
	public synchronized void setLocation(Point location){
		this.location=location;
		if(location.equals(destination))
			dispatcher.notifyAvailable(this);//外部调用方法，可能等待Dispatcher对象锁
	}
}
class Dispatcher{
	private final Set<Taxi> taxis;
	private final Set<Taxi> availableTaxis;
	public Dispatcher(){
		taxis=new HashSet<Taxi>();
		availableTaxis=new HashSet<Taxi>();
	}
	public synchronized void notifyAvailable(Taxi taxi){
		availableTaxis.add(taxi);
	}
	public synchronized Image getImage(){
		Image image=new Image();
		for(Taxi t:taxis)
			image.drawMarker(t.getLocation());//外部调用方法，可能等待Taxi对象锁
		return image;
	}
}

上面的代码中，我们在持有锁的情况下调用了外部的方法，这是非常危险的（可能发生死锁）。为了避免这种危险的情况发生，我们使用开放调用。如果调用某个外部方法时不需要持有锁，我们称之为开放调用。

解决协作对象之间发生的死锁：需要使用开放调用，即避免在持有锁的情况下调用外部的方法。

 

 

 

//正确的代码
class Taxi{
	private Point location,destination;
	private final Dispatcher dispatcher;
	public Taxi(Dispatcher dispatcher) {
		this.dispatcher=dispatcher;
	}
	public synchronized Point getLocation(){
		return location;
	}
	public void setLocation(Point location){
		boolean flag=false;
		synchronized (this) {
			this.location=location;
			flag=location.equals(destination);			
		}
		if(flag)
			dispatcher.notifyAvailable(this);//使用开放调用
	}
}
class Dispatcher{
	private final Set<Taxi> taxis;
	private final Set<Taxi> availableTaxis;
	public Dispatcher(){
		taxis=new HashSet<Taxi>();
		availableTaxis=new HashSet<Taxi>();
	}
	public synchronized void notifyAvailable(Taxi taxi){
		availableTaxis.add(taxi);
	}
	public Image getImage(){
		Set<Taxi> copy;
		synchronized (this) {
			copy=new HashSet<Taxi>(taxis);
		}
		Image image=new Image();
		for(Taxi t:copy)
			image.drawMarker(t.getLocation());//使用开放调用
		return image;
	}
}

 

综上，是常见的3种死锁的类型。即：静态的锁顺序死锁，动态的锁顺序死锁，协作对象之间的死锁。在写代码时，要确保线程在获取多个锁时采用一致的顺序。同时，要避免在持有锁的情况下调用外部方法。

 

 

 

下面补充一点检查死锁的方法：可以用jdk自带的工具来检测是否发生了死锁。命令行下进入JDK的安装文件夹中的bin目录，执行jps命令(全称为JVM process state)，可以得到运行的线程的id值是3333（举个例子，是一个具体的数字）。在执行jstack 3333，查看结果即可。

 

 

 

 

笔者开设了一个知乎live，详细的介绍的JAVA从入门到精通该如何学，学什么？

想深入学习和提高JAVA能力的同学，欢迎收听https://www.zhihu.com/lives/932192204248682496

提供给想学习云计算的同学，欢迎收听https://www.zhihu.com/lives/1046567982750281728