关于一个转账死锁的问题

0 0

关于一个转账死锁的问题0

public class Operation1 {

	private final Object lock = new Object();

	public void transferMoney(final Account fromAccount,
			final Account toAccount, final float dollar) {

		class Helper {
			public void transfer() {
				if (fromAccount.getBalance().compareTo(dollar) < 0) {
					throw new IllegalArgumentException();
				} else {
					fromAccount.setBalance(fromAccount.getBalance() - dollar);
					toAccount.setBalance(toAccount.getBalance() + dollar);
				}
			}
		}

		int fromHashCode = System.identityHashCode(fromAccount);
		int toHashCode = System.identityHashCode(toAccount);

		if (fromHashCode < toHashCode) {
			synchronized (fromAccount) {
				synchronized (toAccount) {
					new Helper().transfer();
				}
			}
		} else if (fromHashCode > toHashCode) {

			synchronized (toAccount) {
				synchronized (fromAccount) {
					new Helper().transfer();
				}
			}
		} else {
			synchronized (lock) {
				synchronized (fromAccount) {
					synchronized (toAccount) {
						new Helper().transfer();
					}
				}
			}
		}

	}

	public static void main(String[] args) {
		final Operation1 o = new Operation1();
		final Account fromAccount = new Account();
		fromAccount.setAccoutName("JetWang");
		fromAccount.setBalance(120000);

		final Account toAccount = new Account();
		toAccount.setAccoutName("china bank");
		toAccount.setBalance(3000);

		new Thread() {
			public void run() {
				o.transferMoney(fromAccount, toAccount, 2000);

			}
		}.start();

		new Thread() {
			public void run() {
				o.transferMoney(toAccount, fromAccount, 1000);

			}
		}.start();
	}

}

背景：如果2个账号同时转账,一个从账号A-B账号,另一个从B账号-A账号
这样就产生了死锁问题。

这一段代码来自于<<java并发编程实践>>中为了解决动态锁顺序死锁。
其中用到了System.identityHashCode方法，我的问题是:
如果这就是一个真实的case，我想问问,通过这种方式能解决死锁正确吗？
怎么感觉很怪,尤其是2个if语句。不太理解他这样做是解决了死锁，但是好像代码跟真实的场景不符合,为什么通过hashcode的大小来决定加锁顺序？，如果是真实的CASE我们该怎么来解决这个次序问题。

死锁

2012年10月15日 14:12

cyril0513
4
0 0 12

2个答案按时间排序按投票排序

0 0

死锁产生：锁获取是环只要解决这个环即可
线程1：锁A    锁B
线程2：      锁B    锁A

        //此处其实有问题如果我调用时是多次new的账户也可能发生死锁
        int fromHashCode = System.identityHashCode(fromAccount);
        int toHashCode = System.identityHashCode(toAccount);

        //可以改成 id 这样就没有问题

        if (fromHashCode < toHashCode) {    //如果from账户uuid<end账户uuid
            synchronized (fromAccount) {      //此时先获取from的锁
                synchronized (toAccount) {     //再获取end的锁即不管从from->end 还是从end转到from 获取锁的顺序固定不会产生环
                    new Helper().transfer();
                }
            }
        } else if (fromHashCode > toHashCode) {

            synchronized (toAccount) {
                synchronized (fromAccount) {
                    new Helper().transfer();
                }
            }
        } else {
            synchronized (lock) {
                synchronized (fromAccount) {
                    synchronized (toAccount) {
                        new Helper().transfer();
                    }
                }
            }
        }

2012年10月15日 21:09

jinnianshilongnian
7280
2 3 591

4条评论

0 0

随便模拟一个长久就可以看出来解过了。

A：HASH33
B：HASH66

CASE1
A->B 50
因为HASH(A)<HASH(B)
synchronized (A)
synchronized (B)

CASE2
B->A 100
因为HASH(B)>HASH(A)
synchronized (A)
synchronized (B)

感觉作者的主要目地是，如果CASE1CASE2同时发生，都会先锁HASH值小的那个USER，所以不会死锁，当HASH值一样，例如自己给自己转，就用一个公共的OBJECT锁住。