1.读写锁

      减少对资源的争用，是提高并发性能的关键。在并发访问中。多个读并发实际不存在线程安全问题，读写，写写并发才是线程安全问题的根源。所以读写锁应运而生。度写锁的使用并不一定都能提高并发性能，这取决于应用场景。如果写多读少，反而会造成性能的下降，因为读写锁显然比普通锁更复杂。在读多写少的场景，无疑读写锁是很好的选择。
     在JAVA的并发包中提供了一个读写锁的实现ReentrantReadWriteLock，使用起来也相当简单。如果想实现一个读写锁的话，以下几个问题是需要考虑的：
1. 读写优先级
2. 锁升级与锁降级
3. 可重入
    一个简单的读写锁实现如下：

package lock;

public class RwLock {

    private int nw = 0;     //获取读锁的线程数
    private int nr = 0;     //获取写锁的线程数，应该为0,1
    private int nreqw = 0; //等待写锁的线程数

    public synchronized void lockRead() throws InterruptedException{
        while(nw > 0 || nreqw > 0) //写优先级高,存在等待写锁线程读线程阻塞
            wait();
        nr++;
    }

    public synchronized void unlockRead(){
        nr--;
        notifyAll();
    }

    public synchronized void lockWrite() throws InterruptedException{
        nreqw++;
        while(nr > 0 || nw > 0)
            wait();
        nreqw--;
        nw++;
    }

    public synchronized void unlockWrite(){
        nw--;
        notifyAll();
    }
}

      这个实现默认写锁优先级高于读锁，但它的写锁不可重入。比如线程A获取写锁，再次请求写锁会被阻塞。解决方法是需要判断请求锁的线程是否为当前线程：

package lock;

public class RwLock {

    private int nw = 0;     //获取读锁的线程数
    private int nr = 0;     //获取写锁的线程数，应该为0,1
    private int nreqw = 0; //等待写锁的线程数

    private Thread currentWThread = null;

    public synchronized void lockRead() throws InterruptedException{
        while(nw > 0 || nreqw > 0) //写优先级高,存在等待写锁线程读线程阻塞
            wait();
        nr++;
    }

    public synchronized void unlockRead(){
        nr--;
        notifyAll();
    }

    public synchronized void lockWrite() throws InterruptedException{
        nreqw++;
        while(!canWrite())
            wait();
        nreqw--;
        nw++;
        currentWThread = Thread.currentThread();
    }

    protected boolean canWrite(){
        if(Thread.currentThread() == currentWThread) //写锁本就已持有
            return true;
        if(nr > 0 || nw > 0)
            return false;
        return true;
    }


    public synchronized void unlockWrite(){
        nw--;
        currentWThread = null;
        notifyAll();
    }
}

      上面已经实现了写优先级高于读，读读可重入，写写可重入。但一个线程获取读锁后，再获取写锁会被阻塞，这显然不合理，这时候需要实现读写锁转换

package lock;

import java.util.HashMap;
import java.util.Map;

public class RwLock {

    private int nw = 0;     //获取读锁的线程数
    private int nreqw = 0; //等待写锁的线程数

    private Thread cwThr = null;
    private Map<Thread, Integer> rThrCnts = new HashMap<Thread,Integer>();

    public synchronized void lockRead() throws InterruptedException{
        while(!canRead())
            wait();
        Thread t = Thread.currentThread();
        rThrCnts.put(t, reads(t));
    }

    protected boolean canRead() {
        Thread t = Thread.currentThread();
        if(t == cwThr) //自己持有写锁
            return true;
        if(nw > 0) //其他线程持有写锁
            return false;
        //到此写锁未被占有，其他线程可能在等写锁，当前线程可能持有读锁
        //当前持有读锁
        if(rThrCnts.get(t) != null)
            return true;
        //当前线程未持有写锁跟读锁，写优先
        if(nreqw > 0)
            return false;
        return true;
    }

    protected int reads(Thread t) {
        Integer cnt = rThrCnts.get(t).intValue();
        if(cnt == null)
            return 0;
        return cnt.intValue();
    }

    public synchronized void unlockRead(){
        Thread t = Thread.currentThread();
        int cnt = reads(t);
        cnt--;
        if(cnt == 0)
            rThrCnts.remove(t);
        else
            rThrCnts.put(t, cnt);
        notifyAll();
    }

    public synchronized void lockWrite() throws InterruptedException{
        nreqw++;
        while(!canWrite())
            wait();
        nreqw--;
        nw++;
        cwThr = Thread.currentThread();
    }

    protected boolean canWrite(){
        if(Thread.currentThread() == cwThr) //写锁本就已持有
            return true;
        //没持有写锁，其他线程是否在写
        if(nw > 0)
            return false;
        //其他线程没持有写锁，判断是否只有自己在读
        if(rThrCnts.size() == 1 && rThrCnts.get(Thread.currentThread()) != null)
            return true;
        //其他线程是否在读
        if(rThrCnts.size() > 0)
            return false;
        //没有任何线程持有读锁跟写锁
        return true;
    }

    public synchronized void unlockWrite(){
        nw--;
        cwThr = null;
        notifyAll();
    }
}