【笔记】高并发编程第二阶段18讲、多线程读写锁分离设计模式讲解

雨点打透心脏的1/2处 2022-03-07 01:10 224阅读 0赞

1.ReadWriteLock

package com.wangwenjun.concurrent.chapter6;
    
    /***************************************
     * @author:Alex Wang
     * @Date:2017/3/19 QQ:532500648
     * QQ交流群:286081824
     ***************************************/
    public class ReadWriteLock {
        private int readingReaders = 0;
        private int waitingReaders = 0;
        private int writingWriters = 0;
        private int waitingWriters = 0;
        private boolean preferWriter = true;
    
        public ReadWriteLock() {
            this(true);
        }
    
        public ReadWriteLock(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();
        }
    }

2.SharedData

public  class SharedData {
    
        private final char[] buffer;
    
        private final  ReadWriteLock lock = new ReadWriteLock();
    
        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();
            }
        }
    
        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 char[] doRead() {
            char[] newBuf = new char[buffer.length];
            for (int i = 0; i < buffer.length; i++)
                newBuf[i] = buffer[i];
    
            slowly(50);
            return newBuf;
        }
    
        private void slowly(int ms) {
            try {
                Thread.sleep(ms);
            } catch (InterruptedException e) {
            }
        }
    }

3.ReaderWorker

public class ReaderWorker extends Thread {
    
        private final SharedData data;
    
        public ReaderWorker(SharedData data) {
            this.data = data;
        }
    
        @Override
        public void run() {
            try {
                while (true) {
                    char[] readBuf = data.read();
                    System.out.println(Thread.currentThread().getName() + " reads " + String.valueOf(readBuf));
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

4.WriterWorker

public class WriterWorker extends Thread {
    
        private static final Random random = new Random(System.currentTimeMillis());
    
        private final SharedData data;
    
        private final String filler;
    
        private int index = 0;
    
        public WriterWorker(SharedData data, String filler) {
            this.data = data;
            this.filler = filler;
        }
    
        @Override
        public void run() {
            try {
                while (true) {
                    char c = nextChar();
                    data.write(c);
                    Thread.sleep(random.nextInt(1000));
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        private char nextChar() {
            char c = filler.charAt(index);
            index++;
            if (index >= filler.length())
                index = 0;
            return c;
        }
    }

5.ReadWritLockClient

public class ReadWritLockClient {
        public static void main(String[] args) {
            final SharedData sharedData = new SharedData(10);
            new ReaderWorker(sharedData).start();
            new ReaderWorker(sharedData).start();
            new ReaderWorker(sharedData).start();
            new ReaderWorker(sharedData).start();
            new ReaderWorker(sharedData).start();
            new WriterWorker(sharedData, "qwertyuiopasdfg").start();
            new WriterWorker(sharedData, "QWERTYUIOPASDFG").start();
        }
    }