并发编程实战死锁读书笔记之吐槽

简单顺序死锁

package com.txr.TransferMoneyDemo;

/**
* Created by txr on 2017/7/28.
*/
public class LeftRightDeadlock {
private final Object left =new Object();
private final Object right=new Object();
public void leftRight(){
synchronized (left){
synchronized (right){
dosomething();
}
}
}
public void rigthLeft(){
synchronized (right){
synchronized (left){
dosomethingElse();
}
}
}
}

显然这样会出现死锁，比如A-->B   B--->A，这个时候第一个线程获得了锁A等待获取锁B，第二个线程线程获取了锁B等待获取锁A，这样就形成了死锁

动态的锁顺序死锁

package com.txr.TransferMoneyDemo;

import javax.naming.InsufficientResourcesException;

/**
* Created by zj-db0236 on 2017/7/28.
*/
public class LeftRightDeadlock {
public void transferMoney(Account fromAcct,Account toAcct,DollarAmout amout) throws InsufficientResourcesException {
synchronized (fromAcct){
synchronized (toAcct){
if(fromAcct.getBalance().compareTo(amout)<0)
throw new InsufficientResourcesException();
else{
fromAcct.debit(amout);
toAcct.credit(amout);
}
}
}
}
}

这种死锁也很容易理解，比如 A--->B   另一个线程  B--->A

A:transferMoney(mycount ,yourAccount,1000)

B:transferMoney(yourcount ,myAccount,2000)

和上面一样会发生死锁

通过锁顺序来避免死锁

private static final Object tieLock =new Object();

/**
* 以顺序锁的形式来转钱，System.identityHashCode是个本地方法，
* 是以引用地址来计算的，HashCode是以值来计算的
* @param fromAcct 转账人
* @param toAcct   被转账人
* @param amout     钱
* @throws InsufficientResourcesException
*/
public static void transferMoney(final Account fromAcct,
final Account toAcct, final DollarAmout amout) throws InsufficientResourcesException {
class Helper{
public void transfer() throws InsufficientResourcesException{
//转账人出账
fromAcct.debit(amout);
//被转账人入账
toAcct.credit(amout);

}
}
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();
}
}
}
}
}

以下来坑了，书上说如下代码典型情况下会发生死锁

public class IdentityHashCodeDemo {
private static final int NUM_THREADS=20;
private static final int NUM_ACCOUNTS=5;
private static final int NUM_ITERATIONS=100000;

/**
* 模拟十万次转账居然会发生死锁这是为什么？
* @param args
*/
public static void main(String[] args) {
final Random rnd=new Random();
final Account[] accounts=new Account[NUM_ACCOUNTS];

for (int i=0;i<accounts.length;i++)
accounts[i]=new Account();
//模拟十万次转账,不考虑账户为负数的情况
class TransferThread extends Thread{
@Override
public void run() {
for(int i=0;i<NUM_ITERATIONS;i++){

int fromAcct=rnd.nextInt(NUM_ACCOUNTS);
int toAcct=rnd.nextInt(NUM_ACCOUNTS);
DollarAmout amout=new DollarAmout(rnd.nextInt(1000));
try {
//很纳闷明明用了顺序锁为什么还会很快出现死锁
transferMoney(accounts[fromAcct],accounts[toAcct],amout);
} catch (InsufficientResourcesException e) {
e.printStackTrace();
}
}
}
}
for (int i=0;i<NUM_THREADS;i++)
new TransferThread().start();
}
}

百思不得其解，最后没办法上网把源码当下来了，查看源码傻眼了，源码如是写着

package net.jcip.examples;

import java.util.*;

import net.jcip.examples.DynamicOrderDeadlock.Account;
import net.jcip.examples.DynamicOrderDeadlock.DollarAmount;

/**
* DemonstrateDeadlock
* <p/>
* Driver loop that induces deadlock under typical conditions
*
* @author Brian Goetz and Tim Peierls
*/
public class DemonstrateDeadlock {
private static final int NUM_THREADS = 20;
private static final int NUM_ACCOUNTS = 5;
private static final int NUM_ITERATIONS = 1000000;

public static void main(String[] args) {
final Random rnd = new Random();
final Account[] accounts = new Account[NUM_ACCOUNTS];

for (int i = 0; i < accounts.length; i++)
accounts[i] = new Account();

class TransferThread extends Thread {
public void run() {
for (int i = 0; i < NUM_ITERATIONS; i++) {
int fromAcct = rnd.nextInt(NUM_ACCOUNTS);
int toAcct = rnd.nextInt(NUM_ACCOUNTS);
DollarAmount amount = new DollarAmount(rnd.nextInt(1000));
try {
DynamicOrderDeadlock.transferMoney(accounts[fromAcct], accounts[toAcct], amount);
} catch (DynamicOrderDeadlock.InsufficientFundsException ignored) {
}
}
}
}
for (int i = 0; i < NUM_THREADS; i++)
new TransferThread().start();
}
}

看到了什么？担心你们粗心我给勾出来了



简直就苦笑不得，书上压根就没有提到这个类，他就默默的用了也不说，然后我们再来看看DynamicOrderDeadlock类

package net.jcip.examples;

import java.util.concurrent.atomic.*;

/**
* DynamicOrderDeadlock
* <p/>
* Dynamic lock-ordering deadlock
*
* @author Brian Goetz and Tim Peierls
*/
public class DynamicOrderDeadlock {
// Warning: deadlock-prone!
public static void transferMoney(Account fromAccount,
Account toAccount,
DollarAmount amount)
throws InsufficientFundsException {
synchronized (fromAccount) {
synchronized (toAccount) {
if (fromAccount.getBalance().compareTo(amount) < 0)
throw new InsufficientFundsException();
else {
fromAccount.debit(amount);
toAccount.credit(amount);
}
}
}
}

static class DollarAmount implements Comparable<DollarAmount> {
// Needs implementation

public DollarAmount(int amount) {
}

public DollarAmount add(DollarAmount d) {
return null;
}

public DollarAmount subtract(DollarAmount d) {
return null;
}

public int compareTo(DollarAmount dollarAmount) {
return 0;
}
}

static class Account {
private DollarAmount balance;
private final int acctNo;
private static final AtomicInteger sequence = new AtomicInteger();

public Account() {
acctNo = sequence.incrementAndGet();
}

void debit(DollarAmount d) {
balance = balance.subtract(d);
}

void credit(DollarAmount d) {
balance = balance.add(d);
}

DollarAmount getBalance() {
return balance;
}

int getAcctNo() {
return acctNo;
}
}

static class InsufficientFundsException extends Exception {
}
}

是不是看完就很好理解为什么在大多数系统下会很快发生死锁了？好坑好坑好坑，一声不说就直接用了个错误的类，以上也说明在附有源码的时候，看书一定要对照源码看，这样能避免很多迷惑性的问题，写此博客也希望能帮到很多跟我一样有困惑的人【我百度，谷歌了很久始终没有找到有人写过这个】