java多线程设计模式(3)读写锁模式

1 Read-Write Lock Pattern

Read-Write Lock Pattern是一种将对于共享资源的访问与修改操作分离,称为读写分离。即访问是reader,修改是write,用单独的线程来处理。可以允许多个reader,但是不允许同时多个写入或者在读的过程中有写入。

由于对于实例状态的读取,并不会破坏状态的完整性且状态也不会修改,可以允许多个线程同时访问操作。但是若在写入的过程中,会更改实例的状态,此时就需要对于写入做保护,防止其他线程来进行读操作和写操作。

在多个线程共享一个实例的时候,会有参考实例状态的线程即仅仅读取实例状态的Reader参与者,并且也会有改变实例的状态的线程即Writer参与者,此时就需要运用这种模式。

  这种模式在读取不会冲突下,允许多个Reader参与者同时reader,提高了性能。不用单纯的在每次读的时候利用Synchronized来使得只能允许一个线程读操作,而是利用了外部定义的逻辑锁来设置允许多个Reader同时操作。在读取的操作比写入的操作多的时候,也可以使用这个模式。

  在这个模式中,主要有四个参与者,分别为:

1 Reader参与者。Reader参与者会对SharedResource参与者进行read。

2 Writer参与者。Writer参与者会对SharedResource参与者进行write。

3 SharedResource参与者。这个是Reader参与者与Writer参与者共享的资源。里面包含了提供不会改变内部状态的操作read,与会改变内部状态的操作write。注意对于这个参与者,不需要在进行read与write的方法加上synchronized。

在对于SharedResource参与者进行read和write操作时候,利用Before/After Pattern实现。

    前置处理(获取锁定)

      try{

      实际操作

       }finally{

        后续处理(释放锁)}

利用finally可以保证无论发生什么情况,都会释放锁,也不能把前置处理放置在try中,如果放置在里面,则finally就一定会执行,当前置处理发生异常,就不应该进而执行finally。

  4 ReadWriteLock参与者。提供了对于SharedResource参与者进行read和write时需要的锁,就是用户自定义的锁机制。包括readLock和readUnLock锁,writeLock和writeUnLock,注意必须要对这些操作进行同步处理,放置多个线程同时调用这些方法,在每个方法中必须加上synchronized。

实例:

有多个读者和多个写者共同操作一本书,只允许同时多个读者读取书,只允许同时一个写者写这本书,不允许同时读者与写者同时操作这本书籍。

SharedResource参与者。

在每次读写操作之间和之后都要获取锁与释放锁,不需要synchronized

package whut.readwritelock;
public class Data {
    private final char[] buffer;
    private final ReadWriteLock lock=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
    {
        lock.readLock();
        try{
            return 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();
        return newbuf;
    }
                                                                                                                                                                                                                                                                                                    
    public void write(char c)throws InterruptedException
    {
        lock.writeLock();
        try{
             doWrite(c);
        }finally{
            lock.writeUnlock();
        }
    }
                                                                                                                                                                                                                                                                                                    
    private void doWrite(char c)
    {
        for(int i=0;i<buffer.length;i++)
        {
            buffer[i]=c;
            slowly();
            //这里的sleep并不会切换到别的线程
            //这里就是体现了使用while的好处
            //当该线程sleep时候,其余等待读取的还在wait中,而要写入的线程会判断它的状态,还没有释放锁
        }
    }
                                                                                                                                                                                                                                                                                                    
    private void slowly()
    {
        try{
            Thread.sleep(50);
        }catch(InterruptedException e)
        {
                                                                                                                                                                                                                                                                                                            
        }
    }
                                                                                                                                                                                                                                                                                                    
}

读者线程Reader

package whut.readwritelock;
public class ReaderThread extends Thread{
    private final Data data;
    public ReaderThread(Data data)
    {
        this.data=data;
    }
                                                                                                                                                                                                                                                                                           
    public void run()
    {
        try{
            while(true)
            {
                char[] readbuf=data.read();
                System.out.println(Thread.currentThread().getName()
                        +" reads "+String.valueOf(readbuf));
            }
        }catch(InterruptedException e)
        {
        }
    }
}

写者线程Writer

package whut.readwritelock;
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);
                Thread.sleep(random.nextInt(1000));
            }
        }catch(InterruptedException e)
        {
                                                                                                                                                                                                                                                                                           
        }
    }
                                                                                                                                                                                                                                                                                   
    private char nextChar()
    {
        char c=filler.charAt(index);
        index++;
        if(index>=filler.length())
            index=0;
        return c;
    }
}

WriteReadLock类

 主要就是利用自定义锁机制来控制读写操作。设置读写时的警戒条件,利用Guarded Suspension Pattern来处理。

  设置有四个字段:

readingReaders表示实例当前被读取的线程数目。是readLock之后与readUnlock之间的数。作为写入操作的警戒条件之一。

  writingReaders表示实例当被写操作的线程数目,只能是0或者1,它是作为写入操作和读取操作的警戒条件。

waitingReaders表示多少个处于等待写入的线程数目。当ReaderThread比WriterThread多的时候,由于在要进行写入操作过程中,如果有读取操作,则会一直等待,但是读取操作没有设置为互斥,则他们会一个个的执行读操作,致使写入操作无法进行。设置这个字段状态目的就是为了使得ReaderThread在警戒条件判断中当waitingReaders大于0的时候,该ReaderThread能wait,能让出控制权给WriterThread。

preferWriter表示true为写优先,表示false为读优先。虽然读取能让出控制权给写入操作,可是当写入操作拥有了控制权后,则可能使得读取操作无法执行。此时就需要这个preferWriter字段,这个就是目的使得ReaderThread和WriterThread能够轮流执行的。

   当读操作完后,设置为true以使得写入操作有可能获得执行,不过写入操作必须在满足preferWriter为true以及有等待写入的操作下才能真正的写入。当写入操作完毕后,设置该字段为false使得读操作能够执行。

总结:

  读取操作等待的警戒条件是:当前写入线程大于0,或者preferWriter为true且有等待写入的线程

  写入操作等待的警戒条件是:当前写入线程大于0,或者当前读取线程大于0

package whut.readwritelock;
//关键部分
public class ReadWriteLock {
    private int readingReaders=0;//实际正在读取的线程数目
    private int waitingWriters=0;//正在等待写入的线程数目
    private int writingWriters=0;//实际正在写入的线程数目
    private boolean preferWriter=true;//写入优先的话,值为true
             
    //读取的时候获取锁
    public synchronized void readLock()throws InterruptedException
    {
        //当有写入的时候,或者写入为优先级并且有等待的写入线程
        while(writingWriters>0||(preferWriter&&waitingWriters>0))
        {
            wait();
        }
        readingReaders++;
    }
             
    //读完毕后释放锁
    public synchronized void readUnlock()throws InterruptedException
    {
        readingReaders--;
        preferWriter=true;
        notifyAll();
    }
             
    //写入的时候获取锁
    public synchronized void writeLock()throws InterruptedException
    {
        waitingWriters++;//正在等待的写入的线程数目
        try{
            //有写入或者读入的时候
            while(readingReaders>0||writingWriters>0)
            {
                wait();
            }
        }finally{
            waitingWriters--;//被唤醒了,则就是进而真正写入
        }
        writingWriters++;
    }
             
    //写入毕后释放锁
    public synchronized void writeUnlock()throws InterruptedException
    {
        writingWriters--;
        preferWriter=false;//写入后马上更换优先级,让读者继续
        notifyAll();
    }
}

测试类:

package whut.readwritelock;
public class ReadWriteMain {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        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();
    }
}

 

    原文作者:java锁
    原文地址: https://www.cnblogs.com/yinliang/p/4201794.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞