java锁 两个顺序的同步引起的问题
java中存在对多个对象加锁的情况，例如： 在银行系统转账时，需要锁定两个账户，这个时候，顺序使用两个synchronized可能存在死锁的情况，在网上搜索到下面的例子：
Java代码
1.public class Bank {
2. final static Object obj_lock = new Object();
3.
4. // Deadlock crisis
5. public void transferMoney(Account from, Account to, int number) {
6. synchronized (from) {
7. synchronized (to) {
8. from.debit();
9. to.credit();
10. }
11. }
12. }
13.
14. // Thread safe
15. public void transferMoney2(final Account from, final Account to, int number) {
16. class Help {
17. void transferMoney2() {
18. from.debit();
19. to.credit();
20. }
21. }
22.
23. int fromHash = from.hashCode();
24. int toHash = to.hashCode();
25. if (fromHash < toHash) {
26. synchronized (from) {
27. synchronized (to) {
28. new Help().transferMoney2();
29. }
30. }
31. } else if (toHash < fromHash) {
32. synchronized (to) {
33. synchronized (from) {
34. new Help().transferMoney2();
35. }
36. }
37. } else {
38. synchronized (obj_lock) {
39. synchronized (to) {
40. synchronized (from) {
41. new Help().transferMoney2();
42. }
43. }
44. }
45. }
46. }
47.}
public class Bank {
final static Object obj_lock = new Object();
// Deadlock crisis
public void transferMoney(Account from, Account to, int number) {
synchronized (from) {
synchronized (to) {
from.debit();
to.credit();
}
}
}
// Thread safe
public void transferMoney2(final Account from, final Account to, int number) {
class Help {
void transferMoney2() {
from.debit();
to.credit();
}
}
int fromHash = from.hashCode();
int toHash = to.hashCode();
if (fromHash < toHash) {
synchronized (from) {
synchronized (to) {
new Help().transferMoney2();
}
}
} else if (toHash < fromHash) {
synchronized (to) {
synchronized (from) {
new Help().transferMoney2();
}
}
} else {
synchronized (obj_lock) {
synchronized (to) {
synchronized (from) {
new Help().transferMoney2();
}
}
}
}
}
}
若操作账户A，B：
1 A的hashCode小于B， 先锁A再锁B
2 B的hashCode小于A， 先锁B再锁A
3 产生的hashCode相等，先锁住一个全局静态变量，在锁A，B
这样就避免了两个线程分别操作账户A,B和B,A而产生死锁的情况。
注意点：
1 需要为Account对象写一个好的hashCode算法，使得不同账户间产生的hashCode尽量不同。
2 如果某次产生hashCode相同锁住obj_lock，那么如果有新的操作再次产生相同hashCode，就必须等待前一次操作完成，可能产生性能问题。(这里应该有更好的方法)
