Java通过锁的顺序避免死锁

内容:通过获取锁的顺序来避免死锁。例如:银行账户转账问题,两个用户转账的话,如果采用一般的synchronized嵌套的话,容易造成死锁,现在我们通过类似哲学家问题的解决方案一样:先获取同一个锁,才有资格获取下一个。而判断是通过System.identityHashCode()来生成类的hashcode()的返回值作为唯一标识,相同的话,我们再加一把锁。

class Account {
	private int money;

	public Account(int money) {
		this.money = money;
	}

	public void debit(int amount) {
		System.out.println("after debit " + amount + " " + this.money + " -> " + (this.money-amount));
		this.money -= amount;
	}

	public void credit(int amount) {
		System.out.println("after credit " + amount + " " + this.money + " -> " + (this.money+amount));
		this.money += amount;
	}

	public int get() {
		return this.money;
	}
}

public class OrderLock {
	private static final Object tieLock = new Object();

	public void transferMoney(final Account fromAcct, final Account toAcct, final int amount)
			throws InsufficientResourcesException {
		class Helper {
			public void transfer() throws InsufficientResourcesException {
				if (fromAcct.get() < amount)
					throw new InsufficientResourcesException();
				else {
					fromAcct.debit(amount);
					toAcct.credit(amount);
				}
			}
		}

		int fromHash = System.identityHashCode(fromAcct);
		int toHash = System.identityHashCode(toAcct);

		if (fromHash < toHash) {
			synchronized (fromAcct) {
				synchronized (toAcct) {
					new Helper().transfer();
				}
			}
		} else if (fromHash > toHash) {
			synchronized (toAcct) {
				synchronized (fromAcct) {
					new Helper().transfer();
				}

			}
		} else {
			synchronized (tieLock) {
				synchronized (fromAcct) {
					synchronized (toAcct) {
						new Helper().transfer();
					}
				}
			}
		}
	}

	class MyThread implements Runnable {
		private Account fromAcct;
		private Account toAcct;
		private int amount;

		public MyThread(Account fromAcct, Account toAcct, int amount) {
			this.fromAcct = fromAcct;
			this.toAcct = toAcct;
			this.amount = amount;
		}

		@Override
		public void run() {
			try {
				transferMoney(this.fromAcct, this.toAcct, this.amount);
			} catch (InsufficientResourcesException e) {
				System.out.println("操作失败");
			}
		}

	}

	public static void main(String[] args) {
		Account fromAcct = new Account(100);
		Account toAcct = new Account(230);
		OrderLock orderLock = new OrderLock();
		ExecutorService threadPool = Executors.newCachedThreadPool();
		for (int i = 0; i < 5; i++) {
			if ((i & 1) == 0)
				threadPool.execute(orderLock.new MyThread(fromAcct, toAcct, 10));
			else threadPool.execute(orderLock.new MyThread(toAcct, fromAcct, 10));
		}
	}
}
时间: 2024-10-12 02:29:48

Java通过锁的顺序避免死锁的相关文章

JAVA基础再回首(二十五)——Lock锁的使用、死锁问题、多线程生产者和消费者、线程池、匿名内部类使用多线程、定时器、面试题

JAVA基础再回首(二十五)--Lock锁的使用.死锁问题.多线程生产者和消费者.线程池.匿名内部类使用多线程.定时器.面试题 版权声明:转载必须注明本文转自程序员杜鹏程的博客:http://blog.csdn.net/m366917 我们来继续学习多线程 Lock锁的使用 虽然我们可以理解同步代码块和同步方法的锁对象问题,但是我们并没有直接看到在哪里加上了锁,在哪里释放了锁,为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的锁对象Lock Lock void lock():获取锁 v

17、Java并发性和多线程-避免死锁

以下内容转自http://ifeve.com/deadlock-prevention/: 在有些情况下死锁是可以避免的.本文将展示三种用于避免死锁的技术: 加锁顺序 当多个线程需要相同的一些锁,但是按照不同的顺序加锁,死锁就很容易发生. 如果能确保所有的线程都是按照相同的顺序获得锁,那么死锁就不会发生.看下面这个例子: Thread 1: lock A lock B Thread 2: wait for A lock C (when A locked) Thread 3: wait for A

java对象锁和类锁

参考 http://www.cnblogs.com/yyyyy5101/archive/2011/07/20/2112157.html http://www.cnblogs.com/kkcheng/archive/2011/02/25/1964521.html http://my.oschina.net/billowworld/blog/120766 1.java对象锁 所有对象都自动含有单一的锁.JVM负责跟踪对象被加锁的次数.如果一个对象被解锁,其计数变为0.在任务(线程)第一次给对象加锁的

java ReentranLock锁

1.效果和synchronized一样,都可以同步执行,lock方法获得锁,unlock方法释放锁 使用示例: package com.test; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class MyService { private Lock lock = new ReentrantLock(); public void methodA()

Java中锁分类

锁的分类大致如下:公平锁/非公平锁可重入锁/不可重入锁独享锁/共享锁乐观锁/悲观锁分段锁 1.公平锁/非公平锁公平锁就是严格按照线程启动的顺序来执行的,不允许其他线程插队执行的:而非公平锁是允许插队的. 默认情况下 ReentrantLock 和 synchronized 都是非公平锁.ReentrantLock 可以设置成公平锁. 2.可重入锁/不可重入锁可重入锁指同一个线程可以再次获得之前已经获得的锁,避免产生死锁. ReenTrantLock可以指定是公平锁还是非公平锁.而synchron

java 常用锁

公平锁和非公平锁 1.公平锁,是指多个线程按照申请的顺序来获取锁,类似排队打饭,先来后到. 2.非公平锁,是指多个线程获取锁的顺序并不是按照申请锁的顺序,有可能后申请的线程 比先申请的线程优先获取锁,在高并发情况下,有可能会造成优先级反转或者饥饿现象. Java ReentrantLock而言,通过构造函数指定该锁是否是公平锁,默认是非公平锁,非公平锁的优点在于吞吐量比公平锁大. 对于Synchronized而言,也是一种非公平锁. 可重入锁(也叫做递归锁) 指的是同一个线程外层函数获得锁之后,

java中锁的概念/介绍

前言 Java提供了种类丰富的锁,每种锁因其特性的不同,在适当的场景下能够展现出非常高的效率.本文旨在对锁相关源码(本文中的源码来自JDK 8和Netty 3.10.6).使用场景进行举例,为读者介绍主流锁的知识点,以及不同的锁的适用场景. Java中往往是按照是否含有某一特性来定义锁,我们通过特性将锁进行分组归类,再使用对比的方式进行介绍,帮助大家更快捷的理解相关知识.下面给出本文内容的总体分类目录: ? 1. 乐观锁 VS 悲观锁 乐观锁与悲观锁是一种广义上的概念,体现了看待线程同步的不同角

SQL Server锁分区特性引发死锁解析

原文:SQL Server锁分区特性引发死锁解析 锁分区技术使得SQL Server可以更好地应对并发情形,但也有可能带来负面影响,这里通过实例为大家介绍,分析由于锁分区造成的死锁情形. 前段时间园友@JentleWang在我的博客锁分区提升并发,以及锁等待实例中问及锁分区的一些特性造成死锁的问题,这类死锁并不常见,我们在这里仔细分析下.不了解锁分区技术的朋友请先看下我的锁分区那篇实例. Code(执行测试脚本时请注意执行顺序,说明) 步骤1 创建测试数据 use tempdb go creat

java中同步嵌套引起的死锁事例代码

/* 目的:自己写一个由于同步嵌套引起的死锁! 思路:多个线程在执行时,某一时刻,0-Thread绑定了LockA锁,1-Thread绑定了LockB锁! 当0-Thread要去绑定LockB锁时 和 1-Thread要去绑定LockA锁时都不能绑定,此时两个线程不能继续进行! */ class Ticket implements Runnable{ public boolean flag; Ticket(boolean flag){ this.flag = flag; } Ticket(){