Java高并发编程详解系列-读写锁分离设计思想

客官°小女子只卖身不卖艺 2021-12-01 12:06 256阅读 0赞

> **导语**  
>   在实际多线程情况下访问共享资源，需要对资源进行同步操作防止数据不一致的情况发生，通常使用的方法式是使用synchronized关键字或者是使用Lock显式锁的方式进行同步资源的锁定。  
>   在对同步资源进行访问的时候不免有两种情况读操作和写操作，对于资源的增删改查不外乎就是这两种方式。当多个线程在对同一个资源进行访问的时候就会出现读写操作的竞争问题。也就是说在同一时刻多个线程同时读或者写，在这个时候就让我们想到的上篇博客中的方式使用排他锁的方式，也就是说当有一个线程占用资源的时候其他线程将不会获得锁。那么我们就来分析一下在那些情况下需要加锁那些情况下不使用锁。

#### 共享资源冲突问题描述 ####

在实际开发中多个线程同一时间进行读操作并不会导致竞争冲突，但是写操作的话就会出现竞争冲突的问题。有些时候我们对数据的要求是以写操作为主，所以在开发中就需要注意到写操作的冲突问题。有的时候我们对于读操作的要求比较高例如查询操作，它并不需要对资源进行修改所以说写操作在有些时候并不会导致资源竞争的出现。那么就为我们提供了一种方法叫做读写分离。在很多的地方都使用到了这种方法论，例如数据库集群、文件存储集群等等。

### 读写分离程序设计 ###

##### 定义Lock接口 #####

public interface Lock { 
        //自定义接口
        // 获取显式锁，没有获得锁的线程将会被阻塞
        void lock() throws InterruptedException;
        
        //释放锁
        void unlock();
        
    }

我们会看到跟Java提供的Lock接口功能类似提供了两个接口方法，一个用来加锁，一个用来解锁。

##### 定义读写锁接口 #####

public interface ReadWriteLock { 
        //创建read锁
        Lock readLock();
        //创建write锁
        Lock writeLock();
    
        //获取当前有多少个线程正在执行写操作
        int getWritingWriters();
    
        //获取当前有多少个线程执行等待读取写操作
        int getWaitngWriters();
    
        //获取当前有多少线程正在等待获取reader锁
        int getReadingReaders();
    
        //工厂方法 ，创建 ReadWriteLock
        static ReadWriteLock readWriteLock(){ 
            return new ReadWriteLockImpl();
        }
        
    
        //工厂方法，创建 ReadWriteLock,并且传入preferWrite
        static ReadWriteLock readWriteLock(boolean preferWriter){ 
            return new ReadWriteLockImpl(preferWriter);
        }
    }

我们看到这个类并不是一个锁定类，也就是说整个类中并没有synchronized关键字，这个类主要的作用是创建读写锁，并且提供了一些查询当前线程访问数的方法。根据整个逻辑会发现当读数大于零就意味着写的个数等于零，当写的个数大于零就意味着读的个数等于零。也就是说读写之间并不冲突，但是读和读之间，写和写之间是存在资源竞争的冲突。

##### 具体实现 #####

public class ReadWriteLockImpl implements ReadWriteLock { 
    
        //定义对象锁
        private final Object MUTEX = new Object();
    
        //当前有多少个线程正在写入操作
        private int writingWriters = 0;
    
        //当前有多少个线程正在等待写入
        private int waitingWriters = 0;
    
        //当前有多少个线程正在read
        private int readingReaders = 0;
    
        //read和write 的偏好设置
        private boolean preferWriter;
    
        //默认情况下perferWriter为True
        public ReadWriteLockImpl(){ 
            this(true);
        }
        
        //构造ReadWriteLockImpl并且传入 perferWriter
        public ReadWriteLockImpl(boolean preferWriter){ 
            this.preferWriter = preferWriter;
        }
    
    
        //read lock
        @Override
        public Lock readLock() { 
            return new ReadLock(this);
        }
    
        // write lock
        @Override
        public Lock writeLock() { 
            return new WriteLock(this);
        }
    
        //写线程数增加
        void incrementWritingWriters(){ 
            this.writingWriters++;
        }
        //等待写入的线程数增加
        void incrementWaitingWriters(){ 
            this.waitingWriters++;
        }
    
       //读线程数增加
        void incrementReadingReaders(){ 
            this.readingReaders++;
        }
        
        //等待写线程数减少
        void decrementWaitingWriters(){ 
            this.waitingWriters--;
        }
        //写线程数减少
        void decrementWritinggWriters(){ 
            this.writingWriters--;
        }
        //读线程数减少
        void decrementReadingReaders(){ 
            this.readingReaders--;
        }
        
        //获取当前有多少个线程正在进行写操作
        @Override
        public int getWritingWriters() { 
            return this.writingWriters;
        }
        
        //获取当前有多少个线程正在等待获取写入操作
        @Override
        public int getWaitngWriters() { 
            return this.waitingWriters;
        }
    
        //获取当前有多少个线程正在进行读操作
        @Override
        public int getReadingReaders() { 
            return this.readingReaders;
        }
    
        //获取对象锁
        public Object getMUTEX() { 
            return this.MUTEX;
        }
    
        //获取当前是否偏向写锁
        public boolean getPreferWriter() { 
            return preferWriter;
        }
    
        //设置写锁偏好
        void changePrefer(boolean preferWriter){ 
            this.preferWriter = preferWriter;
        }
    }

我们看到在开发过程中使用到了一个对象锁的操作，并且还设置了一个偏好设置用来控制锁的倾向性，用来控制读写操作的量级。

##### ReadLock #####

public class ReadLock implements Lock { 
    
        private final ReadWriteLockImpl readWriteLock;
    
        public ReadLock(ReadWriteLockImpl readWriteLock){ 
            this.readWriteLock = readWriteLock;
        }
    
        @Override
        public void lock() throws InterruptedException { 
            //使用Mutex作为锁
            synchronized (readWriteLock.getMUTEX()){ 
                //当前满足条件的时候此锁挂起等待
                while (readWriteLock.getWritingWriters()>0 || (readWriteLock.getPreferWriter()&& readWriteLock.getWaitngWriters()>0)){ 
                    readWriteLock.getMUTEX().wait();
                }
                //获取到读锁的数量增加
                readWriteLock.incrementReadingReaders();
            }
        }
    
        @Override
        public void unlock() { 
    
            //锁定对象
            synchronized (readWriteLock.getMUTEX()){ 
                //减少读锁
                readWriteLock.decrementReadingReaders();
                //修改锁偏向
                readWriteLock.changePrefer(true);
                //唤醒被锁定的线程
                readWriteLock.getMUTEX().notifyAll();
            }
        }
    }

*  1 、当前如果么有任何线程对数据进行写操作的时候，读线程才可以获取到锁的所有权，当然多个线程在等待获取写锁的所有权时读线程也会进入到Mutex的等待集合中，这个时候等待读的数量会增加。
 *  2、当读线程释放锁，也就是说reader数量减少同时唤醒在Mutex等待集合中的线程，reader唤醒的都是在获取写锁而进入阻塞的线程，在一定的程度上为了提升获取锁的机会就要对偏好设置为true。

##### WriteLock #####

public class WriteLock implements Lock { 
    
        private final ReadWriteLockImpl readWriteLock;
    
    
        public WriteLock(ReadWriteLockImpl readWriteLock){ 
            this.readWriteLock = readWriteLock;
        }
    
        @Override
        public void lock() throws InterruptedException { 
    
            synchronized (readWriteLock.getMUTEX()){ 
                try { 
                    //等待数增加
                    readWriteLock.incrementWaitingWriters();
                    //判断正在读或者写线程挂起
                    while (readWriteLock.getReadingReaders()>0||readWriteLock.getWritingWriters()>0){ 
                        readWriteLock.getMUTEX().wait();
                    }
                }finally { 
                    //成功等待写入锁减少1
                    this.readWriteLock.decrementWaitingWriters();
                }
                //正在写锁加一
                readWriteLock.incrementWritingWriters();
            }
        }
    
        @Override
        public void unlock() { 
            synchronized (readWriteLock.getMUTEX()){ 
                //减少写入
                readWriteLock.decrementWritinggWriters();
                //设置偏好
                readWriteLock.changePrefer(false);
                //唤醒线程
                readWriteLock.getMUTEX().notifyAll();
            }
    
        }
    }

*  1、当前如果有线程进行读写操作的时候如果当前线程试图获取锁则将会进入到对象锁的等待集合中，同时就是增加等待锁的数量。当时如果被激活的时候就要从等待中减少。
 *  2、写锁的释放与读锁的释放正好相反，将偏好设置为false提高读锁的机会。

##### 怎么使用呢？ #####

**建立共享数据**

public class ShareData { 
        //定义共享数据
        private final List<Character> container = new ArrayList<>();
    
        //构造ReadWrite锁
        private final ReadWriteLock readWriteLock = ReadWriteLock.readWriteLock();
    
        //读锁
        private final Lock readLock = readWriteLock.readLock();
    
        //写锁
        private final Lock writeLock = readWriteLock.writeLock();
    
        
        private final int length;
    
        public ShareData(int length){ 
            this.length = length;
            for (int i = 0; i < length; i++) { 
                container.add(i,'c');
            }
        }
    
        public char[] read() throws InterruptedException { 
            try { 
                //读锁定
                readLock.lock();
                char[] newBuffer = new char[length];
    
                for (int i = 0; i < length; i++) { 
                    newBuffer[i] = container.get(i);
                }
                slowly();
                return newBuffer;
    
            }finally { 
                //释放读锁
                readLock.unlock();
            }
        }
    
        public void write(char c) throws InterruptedException{ 
            try{ 
                //写锁定
                writeLock.lock();
                for (int i = 0; i < length; i++) { 
                    this.container.add(i,c);
                }
                slowly();
    
            }finally { 
                //释放写锁
                writeLock.unlock();
            }
        }
    
        private void slowly(){ 
            try { 
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }
    
    }

**模拟多线程访问**

public class ReadWriteLockTest { 
        private final static String text ="HelloWorld";
    
        public static void main(String[] args) { 
            final ShareData shareData = new ShareData(50);
    
            for (int i = 0; i < 2; i++) { 
                new Thread(()->{ 
                    for (int j = 0; j < text.length(); j++) { 
                        try { 
                            char c = text.charAt(j);
                            shareData.write(c);
                            System.out.println(currentThread()+" write " + c);
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
                    }
                }).start();
            }
    
            for (int i = 0; i < 10; i++) { 
                new Thread(()->{ 
                    while (true){ 
                        try{ 
                            System.out.println(currentThread()+" read "+new String(shareData.read()));
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
                    }
                }).start();
            }
        }
    }

建立两个写线程，建立十个读线程。看看最后的运行效果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70]

## 总结 ##

从最后的结果看到我们的思路是正确的，在Java开发中也在不断的进行锁的优化操作。这些优化不但在开发者层面，在JDK层面，更是在设计思路层面，有一个好的设计思路结合合理的开发技术才能做出高效的应用。对于读写锁的实现思路已经被使用到了各个领域。当然要根据不同的使用场景做出合适的调整不能一味的生搬硬套。在后续的分享中对锁的操作还会有具体的深入的分析。敬请期待。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70]: /images/20211201/0e76d83f19e744a689e1c089c996b454.png