读写分离锁,读写锁设计模式

一、读写锁的工作原理是:

  • 当「写锁」没有被线程持有时,多个线程能够并发地持有读锁,这大大提高了共享资源的访问效率,因为「读锁」是用于读取共享资源的场景,所以多个线程同时持有读锁也不会破坏共享资源的数据。
  • 但是,一旦「写锁」被线程持有后,读线程的获取读锁的操作会被阻塞,而且其他写线程的获取写锁的操作也会被阻塞。

所以说,写锁是独占锁,因为任何时刻只能有一个线程持有写锁,类似互斥锁和自旋锁,而读锁是共享锁,因为读锁可以被多个线程同时持有。

知道了读写锁的工作原理后,我们可以发现,读写锁在读多写少的场景,能发挥出优势。

另外,根据实现的不同,读写锁可以分为「读优先锁」和「写优先锁」。

1、读优先锁期望的是,读锁能被更多的线程持有,以便提高读线程的并发性,它的工作方式是:当读线程 A 先持有了读锁,写线程 B 在获取写锁的时候,会被阻塞,并且在阻塞过程中,后续来的读线程 C 仍然可以成功获取读锁,最后直到读线程 A 和 C 释放读锁后,写线程 B 才可以成功获取读锁。如下图:
在这里插入图片描述

2、而写优先锁是优先服务写线程,其工作方式是:当读线程 A 先持有了读锁,写线程 B 在获取写锁的时候,会被阻塞,并且在阻塞过程中,后续来的读线程 C 获取读锁时会失败,于是读线程 C 将被阻塞在获取读锁的操作,这样只要读线程 A 释放读锁后,写线程 B 就可以成功获取读锁。如下图:
在这里插入图片描述

读优先锁对于读线程并发性更好,但也不是没有问题。我们试想一下,如果一直有读线程获取读锁,那么写线程将永远获取不到写锁,这就造成了写线程「饥饿」的现象。

写优先锁可以保证写线程不会饿死,但是如果一直有写线程获取写锁,读线程也会被「饿死」。

既然不管优先读锁还是写锁,对方可能会出现饿死问题,那么我们就不偏袒任何一方,搞个「公平读写锁」。

公平读写锁比较简单的一种方式是:用队列把获取锁的线程排队,不管是写线程还是读线程都按照先进先出的原则加锁即可,这样读线程仍然可以并发,也不会出现「饥饿」的现象。

转载自

二、自己实现读写锁

对于共享数据的操作无非读和写,多线程条件下,对于共享资源是否冲突,如下图:
在这里插入图片描述
如上可以看出对于写操作是不需要加锁的,这样可以很大提升性能;写操作都需要具有排他方式的加锁。

public class ReadWriteLock {
    //等待读操作线程数
    private int watingReades;
    //正在读得线程数,这里支持多线程同时读取
    private int readeingReades;
    //等待写的线程数
    private int wateingWrites;
    //正在写的线程数,写操作冲突所以支持单线程操作,所以数量不能大于1
    private int writingWrites;
    //操作偏好,true:偏向于写线程  false:偏向于读线程
    private boolean preferWriter;

    public ReadWriteLock() {
        //默认偏向于写线程
        this(true);
    }

    public ReadWriteLock(boolean preferWriter) {
        this.preferWriter = preferWriter;
    }

    //读锁
    public synchronized void lockReade() throws InterruptedException {
        //等待写线程数量增加,使用finally保证一定执行
        watingReades++;
        try {
            //正在写操作 或 有等待写线程并且偏向于写,则无法获取读锁,被挂起
            while (writingWrites > 0 || (preferWriter && wateingWrites > 0)) {
                this.wait();
            }
            //成功获取读锁,正在写线程数量增加
            readeingReades++;
        }finally {
            watingReades--;
        }

    }

    public synchronized void unlockReade(){
        readeingReades--;
        //为了保证读写锁获取的概率一样
        this.preferWriter = true;
        this.notifyAll();
    }

    public synchronized void lockWrite() throws InterruptedException {
        wateingWrites++;
        try{
            //正在读操作或正在写操作,则进入this的waiter set中而被阻塞
            while (readeingReades > 0 || writingWrites > 0){
                this.wait();
            }
            writingWrites++;
        }finally {
            wateingWrites--;
        }
    }

    public synchronized void unlockWrite() {
        writingWrites--;
        //为了保证读写锁获取的概率一样
        this.preferWriter = false;
        this.notifyAll();
    }
}
public class ShareData {

    private final char[] buffer;
    private ReadWriteLock lock = new ReadWriteLock();

    public ShareData(int size) {
        buffer = new char[size];
        for (int i = 0 ;i < size ; i++){
            buffer[i] = 'c';
        }
    }

    public char[] rader() throws InterruptedException {
        char[] chars = new char[buffer.length];

        try {
            lock.lockReade();
            for (int i = 0; i < buffer.length; i++) {
                chars[i] = buffer[i];
            }
        } finally {
            lock.unlockReade();
        }
        slowly();
        return chars;
    }


    public void write(char c) throws InterruptedException {
        try{
            lock.lockWrite();
            for (int i = 0; i < buffer.length; i++) {
                buffer[i] = c;
            }
            slowly();
        }finally {
            lock.unlockWrite();
        }
    }

    private void slowly(){
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class ReadeThread extends Thread {

    private final ShareData data;

    public ReadeThread(ShareData data){
        this.data=data;
    }

    @Override
    public void run() {
        try {
            while (true) {
                char[] rader = data.rader();
                System.out.println(currentThread()+" reade "+ String.valueOf(rader));
            }
        }catch (Exception e){

        }
    }
}
public class WriteThread extends Thread {

    private final ShareData data;
    private final String filler;
    private int index;

    public WriteThread(ShareData data,String filler){
        this.data=data;
        this.filler=filler;
    }

    @Override
    public void run() {
        try {
            while (true) {
                char c = writeChar();
                System.out.println(currentThread()+" write "+ c);
            }
        }catch (Exception e){

        }
    }

    private char writeChar() throws InterruptedException {
        char c = filler.charAt(index);
        data.write(c);
        index++;
        if(index >= filler.length())
            index = 0;
        return c;
    }
}
public class ReadWriteTest {

    public static void main(String[] args) {
        ShareData shareData = new ShareData(10);
        new ReadeThread(shareData).start();
        new ReadeThread(shareData).start();
        new ReadeThread(shareData).start();
        new ReadeThread(shareData).start();
        new ReadeThread(shareData).start();

        new WriteThread(shareData,"qazwsxewdcv").start();
        new WriteThread(shareData,"QAZWSXEWDCV").start();
    }
}
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页