读写锁

媒介

//要在读写线程间传来传去的,"被操作对象"。
public  class SharedData {
    //设置要写的内容
    private final char[] buffer;
    //读写锁
    private final Read_Write_Lock lock = new Read_Write_Lock();
    //默认初始要读的内容
    public SharedData(int  size) {
        this.buffer = new char[size];
        for (int i = 0; i < size; i++) {
            this.buffer[i] = '*';
        }
    }
    //拿锁-->开始读-->释放锁
    public char[] read() throws InterruptedException {
        try {
            lock.readLock();
            return this.doRead();
        } finally {
            lock.readUnlock();
        }
    }
    //开始读数组里的内容
    private char[] doRead() {
        char[] newBuf = new char[buffer.length];
        for (int i = 0; i < buffer.length; i++){
            newBuf[i] = buffer[i];
        }
        slowly(500);
        return newBuf;
    }
    //拿锁->开始写->释放锁
    public void write(char c) throws InterruptedException {
        try {
            lock.writeLock();
            this.doWrite(c);
        } finally {
            lock.writeUnlock();
        }
    }
    //更改数组里内容
    private void doWrite(char c) {
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] = c;
            slowly(10);
        }
    }
    //休眠
    private void slowly(int ms) {
        try {
            Thread.sleep(ms);
        } catch (InterruptedException e) {
        }
    }
}

读线程

//读线程
public class ReaderWorker extends Thread {

    private final SharedData data;

    public ReaderWorker(SharedData data) {
        this.data = data;
    }

    @Override
    public void run() {
        try {
            //设为true，可以一直循环下去
            while (true) {
                char[] readBuf = data.read();
                System.out.println(Thread.currentThread().getName() + " 读线程,开始读: " + String.valueOf(readBuf));
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

写线程

//写线程
public class WriterWorker extends Thread {

    private final SharedData data;
    //要写入的文本
    private final String filler;

    private static int index = 0;
    //data为要操作的对象,filler为要写的文本
    public WriterWorker(SharedData data, String filler) {
        this.data = data;
        this.filler = filler;
    }

    @Override
    public void run() {
        try {
            //设为true，可以一直循环下去
            while (true) {
                char c = nextChar();
                data.write(c);
                System.out.println(Thread.currentThread().getName() + " 写线程,开始写: " + String.valueOf(c));
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //
    private char nextChar() {
        char c = filler.charAt(index);
        index++;
        if (index >= filler.length())
            index = 0;
        return c;
    }
}

读写锁（控制核心）

//读写锁
public class Read_Write_Lock {
    //正在读的线程数量
    private int readingReaders = 0;
    //等待读的线程数量
    private int waitingReaders = 0;
    //正在写的线程数量
    private int writingWriters = 0;
    //等待写的线程数量
    private int waitingWriters = 0;
    //设置写线程优先
    private boolean preferWriter = true;
    //默认写的优先级高
    public Read_Write_Lock() {
        this(true);
    }
    //设置写的线程是否需要优先
    public Read_Write_Lock(boolean preferWriter) {
        this.preferWriter = preferWriter;
    }
    //读锁
    public synchronized void readLock() throws InterruptedException {
        this.waitingReaders++;
        try {
            while (writingWriters > 0 || (preferWriter && waitingWriters > 0)) {
                this.wait();
            }
            this.readingReaders++;
        } finally {
            this.waitingReaders--;
        }
    }
    //释放读锁
    public synchronized void readUnlock() {
        this.readingReaders--;
        this.notifyAll();
    }
    //写锁
    public synchronized void writeLock() throws InterruptedException {
        this.waitingWriters++;
        try {
            while (readingReaders > 0 || writingWriters > 0) {
                this.wait();
            }
            this.writingWriters++;
        } finally {
            this.waitingWriters--;
        }
    }
    //释放写锁
    public synchronized void writeUnlock() {
        this.writingWriters--;
        this.notifyAll();
    }
}

测试

    public static void main(String[] args) {

        final SharedData sharedData = new SharedData(10);
        //启动读线程
        new ReaderWorker(sharedData).start();
        new ReaderWorker(sharedData).start();
        //启动写线程
        new WriterWorker(sharedData, "asdf").start();
    }