[多线程]Read-Write Lock模式

痛定思痛。 2022-05-28 11:42 99阅读 0赞

学生们正在一起看老师在黑板上写的板书,这时,老师想擦掉板书,再写新的内容.而学生们说道:"老师,我们还没看完,don't wipe it!"于是,老师会等待大家看完.

在线程"读取"实例的状态时,实例的状态不会发生变化.实例的状态仅在线程"写入"时才会发生变化.

ReadWriteLock类:

public class ReadWriteLock {
    	private int readingReaders = 0; //正在读取的线程数量
    	private int writingWriters = 0; //正在写入的线程数量
    
    	public synchronized void readLock() throws InterruptedException {
    		while (writingWriters > 0) { //如果有线程在执行写入,等待.
    			wait();
    		}
    		readingReaders++;  //实际在读取的线程+1
    	}
    
    	public synchronized void unReadLock() {
    		readingReaders--;  //实际读取线程-1
    		notifyAll();
    	}
    
    	public synchronized void writeLock() throws InterruptedException {
    		while (writingWriters > 0 || readingReaders > 0) { //如果有线程正在写入,或者在读取 等待
    			wait();
    		}
    		writingWriters++; //正在写入的线程+1
    	}
    
    	public synchronized void unWriteLock() {
    		writingWriters--; //正在写入的线程-1
    		notifyAll();
    	}
    }

该类提供了用于读取的锁和用于写入的锁.;

为了保证安全性,我们必须防止两种冲突.

1.read和write的冲突

2.write和write的冲突.

因为read和read不存在冲突,所以我们不需要考虑他们.

为了防止冲突,我们来思考一下获取用于读取的锁和用于写入的锁的条件.这里存在4种情况.

1.当线程想获取用于读取的锁时.

(1)如果有线程正在写入,等待.

because:会引起read write conflict.

(2)如果有线程正在读取.无需等待.

because:read read 不会引起conflict.

2.当线程想要获取用于写入的锁时

(3)如果有线程正在写入,等待.

because:会引起write write conflict.

(4)如果有现成正在读取,等待.

because:会引起read write conflict.

Data类:

import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    public class Data {
    	private final char[] buffer;
    	private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); //这个其实是java.util.concurrent.locks写好的读写锁类,可以直接调用 不用自己写啦.
    	private final Lock readLock = lock.readLock();//读锁
    	private final Lock writeLock = lock.writeLock();//写锁
    	private final ReadWriteLock readWriteLock = new ReadWriteLock();//我们自己实现的读写锁类
    
    	public Data(int size) {
    		this.buffer = new char[size];
    		for (int i = 0; i < buffer.length; i++) {
    			buffer[i] = '*';
    		}
    	}
    
    	public char[] read() throws InterruptedException {
    		readWriteLock.readLock();
    		try {
    			return doRead();
    		} finally {
    			readWriteLock.unReadLock();
    		}
    	}
    
    	public void write(char c) throws InterruptedException {
    		readWriteLock.writeLock();
    		try {
    			doWrite(c);
    		} finally {
    			readWriteLock.unWriteLock();
    		}
    	}
    
    	private char[] doRead() {
    		char[] newbuf = new char[buffer.length];
    		for (int i = 0; i < newbuf.length; i++) {
    			newbuf[i] = buffer[i];
    		}
    		slowly();
    		return newbuf;
    	}
    
    	private void slowly() {
    		try {
    			Thread.sleep(50);
    		} catch (InterruptedException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    
    	private void doWrite(char c) {
    		for (int i = 0; i < buffer.length; i++) {
    			buffer[i] = c;
    			slowly();
    		}
    	}
    }

WriterThread类:

import java.util.Random;
    
    public class WriterThread extends Thread {
    	private static final Random random = new Random();
    	private final Data data;
    	private final String filler;
    	private int index = 0;
    
    	public WriterThread(Data data, String filler) {
    		this.data = data;
    		this.filler = filler;
    	}
    
    	public void run() {
    		try {
    			while (true) {
    				char c = nextchar();
    				data.write(c);
    				System.out.println(Thread.currentThread().getName()+"write"+c);
    				Thread.sleep(random.nextInt(3000));
    			}
    		} catch (InterruptedException e) {
    			// TODO: handle exception
    		}
    	}
    
    	private char nextchar() {
    		char c = filler.charAt(index);
    		index++;
    		if (index >= filler.length()) {
    			index = 0;
    		}
    		return c;
    	}
    }

ReadThread类:

public class ReaderThread extends Thread {
    	private final Data data;
    
    	public ReaderThread(Data data) {
    		this.data = data;
    	}
    	public void run() {
    		try {
    			while (true) {
    				char[] read = data.read();
    				System.out.println(Thread.currentThread().getName()+" reads "+String.valueOf(read));
    				Thread.sleep(1000);
    			}
    		} catch (InterruptedException e) {
    			// TODO: handle exception
    		}
    	}
    }

Main:

public class Main {
    	public static void main(String[] args) {
    		Data data = new Data(10);
    		new ReaderThread(data).start();
    		new ReaderThread(data).start();
    		new ReaderThread(data).start();
    		new ReaderThread(data).start();
    		new ReaderThread(data).start();
    		new ReaderThread(data).start();
    		new WriterThread(data, "abcdefghijklmnopqrstuvwxyz").start();
    		new WriterThread(data, "ABCDEFGHIJKLMNOPQRSTUVWXYZ").start();
    	}
    }