java多线程8.性能与活跃性问题

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 rightLeft(){
        synchronized(right){
            synchronized(left){
                dosomething();
            }
        }
    }
}

    // 事实上锁的顺序取决于传递给transferMoney的参数顺序，而这些参数又取决于外部输入。这种情况下，外部调用很容易发生死锁。
    public 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);
                }
            }
        }
    }

    private static final Object tieLock = new Object();

    /**
     * 在指定锁的顺序时，可以使用System.identityHashCode。在极少数情况下，两个对象可能拥有相同的散列值，此时再在外面加一层锁，
     * 保证每次只有一个线程以一致的顺序获得两个锁，从而消除死锁的可能性。
     * 如果Account中包含一个唯一的、不可变的，并且具备可比性的键值，如账号那么要制定锁的顺序就更加容易了，也就不需要再另外加锁了。
     * 
     * @param fromAccount
     * @param toAccount
     * @param amount
     * @throws InsufficientFundsException
     */
    public void transferMoney2(final Account fromAccount,final Account toAccount,final DollarAmount amount)
            throws InsufficientFundsException{

        class Helper{
            public void transfer() throws InsufficientFundsException{
                if(fromAccount.getBalance().compareTo(amount) < 0){
                    throw new InsufficientFundsException();
                }else{
                    fromAccount.debit(amount);
                    toAccount.credit(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(tieLock){
                synchronized(fromAccount){
                    synchronized(toAccount){
                        new Helper().transfer();
                    }
                }
            }
        }
    }

/**
 * 尽管没有任何方法会显示地获取两个锁，但setLocation和getImage等方法的调用都会获得两个锁。
 * 如果一个线程收到GPS接收器的更新事件时调用setLocation，那么它将首先更新出租车的位置，然后判断它是否到达了目的地。
 * 如果已经到达，它会通知Dispatcher：它需要一个新的目的地。
 * setLocation与norifyAvailable将先后获得Taxi和Dispatcher的锁而getImage与getLocation将先后获得Dispatcher与Taxi的锁。因此就可能产生死锁。
 */
class Taxi{
    private Point location;
    private Point destination;
    private final Dispatcher dispather;

    public Taxi(Dispatcher dispather){
        this.dispather = dispather;
    }

    public synchronized Point getLocation(){
        return location;
    }

    public synchronized void setLocation(Point destination){
        this.location = location;
        if(location.equals(destination)){
            dispather.norifyAvailable(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 norifyAvailable(Taxi taxi){
        availableTaxis.add(taxi);
    }

    public synchronized Image getImage(){
        Image image = new Image();
        for(Taxi t : taxis){
            image.drawMarker(t.getLocation());
        }
        return image;
    }
}

/**
 * 将Taxi与Dispatcher修改为开放调用，从而消除发生死锁的风险。使用同步代码块仅保护哪些设计共享状态的操作。在同步操作中不会去获得另外的锁。
 */
class Taxi1{
    private Point location;
    private Point destination;
    private final Dispatcher1 dispather;

    public synchronized Point getLocation(){
        return location;
    }

    public void setLocation(Point location){
        boolean reachedDestination;
        synchronized(this){
            this.location = location;
            reachedDestination = location.equals(destination);
        }
        if(reachedDestination){
            dispather.norifyAvailable(this);
        }
    }
}

class Dispatcher1{
    private final Set<Taxi1> taxis;
    private final Set<Taxi1> availableTaxis;

    public synchronized void norifyAvailable(Taxi1 taxi){
        availableTaxis.add(taxi);
    }

    public Image getImage(){
        Set<Taxi1> copy;
        synchronized(this){
            copy = new HashSet<Taxi1>(taxis);
        }
        Image image = new Image();
        for(Taxi1 t : copy){
            image.drawMarker(t.getLocation());
        }
        return image;
    }
}

/**
 * StripedMap中给出了基于散列的Map实现，其中使用了锁分段技术。它拥有N_LOCKS个锁，并且每个锁保护散列桶的一个子集。
 * 例如get都只需要获得一个锁，而有些方法则需要获得所有的锁，但并不要求同时获得，例如clear
 */
public class StripedMap {
    
    private static final int N_LOCKS = 16;
    
    private final Node[] buckets;
    
    private final Object[] locks;
    
    private static class Node{
        
    }
    
    public StripedMap(int numBuckets){
        buckets = new Node[numBuckets];
        locks = new Object[N_LOCKS];
        for(int i = 0;i < N_LOCKS; i++){
            locks[i] = new Object();
        }
    }
    
    private final int hash(Object key){
        return Math.abs(key.hashCode() % buckets.length);
    }
    
    public Object get(Object key){
        int hash = hash(key);
        synchronized(locks[hash % N_LOCKS]){
            for(Node m = buckets[hash]; m != null; m = m.next()){
                if(m.key.equals(key)){
                    return m.value;
                }
            }
        }
        return null;
    }
    
    public void clear(){
        for(int i = 0; i < buckets.length; i++){
            synchronized(locks[i % N_LOCKS]){
                buckets[i] = null;
            }
        }
    }
}