ReadWriteLock

        多線程讀寫同一個(gè)對(duì)象的數(shù)據(jù)是很普遍的，通常，要避免讀寫沖突，必須保證任何時(shí)候僅有一個(gè)線程在寫入，有線程正在讀取的時(shí)候，寫入操作就必須等待。簡(jiǎn)單說(shuō)，就是要避免“寫-寫”沖突和“讀-寫”沖突。但是同時(shí)讀是答應(yīng)的，因?yàn)椤白x-讀”不沖突，而且很安全。

       要實(shí)現(xiàn)以上的ReadWriteLock，簡(jiǎn)單的使用synchronized就不行，我們必須自己設(shè)計(jì)一個(gè)ReadWriteLock類，在讀之前，必須先獲得“讀鎖”，寫之前，必須先獲得“寫鎖”。舉例說(shuō)明：

DataHandler對(duì)象保存了一個(gè)可讀寫的char[]數(shù)組：

package com.crackj2ee.thread;

public class DataHandler {
    // store data:
    PRivate char[] buffer = "AAAAAAAAAA".toCharArray();

    private char[] doRead() {
        char[] ret = new char[buffer.length];
        for(int i=0; i            ret[i] = buffer[i];
            sleep(3);
        }
        return ret;
    }

    private void doWrite(char[] data) {
        if(data!=null) {
            buffer = new char[data.length];
            for(int i=0; i                buffer[i] = data[i];
                sleep(10);
            }
        }
    }

    private void sleep(int ms) {
        try {
            Thread.sleep(ms);
        }
        catch(InterruptedException ie) {}
    }
}

doRead()和doWrite()方法是非線程安全的讀寫方法。為了演示，加入了sleep()，并設(shè)置讀的速度大約是寫的3倍，這符合通常的情況。

為了讓多線程能安全讀寫，我們?cè)O(shè)計(jì)了一個(gè)ReadWriteLock：

package com.crackj2ee.thread;
public class ReadWriteLock {
    private int readingThreads = 0;
    private int writingThreads = 0;
    private int waitingThreads = 0; // waiting for write
    private boolean preferWrite = true;

    public synchronized void readLock() throws InterruptedException {
        while(writingThreads>0 (preferWrite && waitingThreads>0))
            this.wait();
        readingThreads++;
    }

    public synchronized void readUnlock() {
        readingThreads--;
        preferWrite = true;
        notifyAll();
    }

    public synchronized void writeLock() throws InterruptedException {
        waitingThreads++;
        try {
            while(readingThreads>0 writingThreads>0)
                this.wait();
        }
        finally {
            waitingThreads--;
        }
        writingThreads++;
    }

    public synchronized void writeUnlock() {
        writingThreads--;
        preferWrite = false;
        notifyAll();
    }
}