栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

多线程基础之设计模式Read-Write-Lock模式

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

多线程基础之设计模式Read-Write-Lock模式

 一. Read-Write-Lock介绍

        当线程 "读取" 实例状态时, 实例的状态不会发生改变, 当线程 "写入" 数据时, 实例的状态会发生改变, 在 Read-Write-Lock 模式中, 读取操作和写入操作是分开考虑的, 在执行读取操作之前, 线程必须获取用于读取的锁, 以防止其他线程写入, 而在执行写操作之前, 线程必须获取用于写入的锁

二. 示例程序
类名说明
Main测试主程序
ReadThread表示读取线程类
WriteThread表示写入线程类
Data可以被读写的类
ReadWriteLock提供读写锁的类
2.1 Main类

        Main 类会创建一个 Data 的实例, 然后创建对该 Data 实例读取操作的线程(ReadThread), 以及执行写入的线程(WriteThread), 并启动线程

public class Main {
    public static void main(String[] args) {
        Data data = new Data(10);
        // 读线程
        new ReadThread(data).start();
        new ReadThread(data).start();
        new ReadThread(data).start();
        new ReadThread(data).start();
        new ReadThread(data).start();
        new ReadThread(data).start();
        new ReadThread(data).start();
        // 写线程
        new WriteThread(data, "abcdefg").start();
        new WriteThread(data, "ABCDEFG").start();
    }
}
2.2 Data类

        Data 类是可以执行读取和写入操作的类, buffer 字段是实际的读写对象的char类型数组, lock字段保存的是该模式的主角 ReadWriteLock 的实例, 构造函数会根据参数的传入长度来分配一个 char 数组, 并初始化 buffer 字段, read()方法用于执行读取操作, 实际的读取操作是通过 doRead()方法来执行, 而 doRead()方法 夹在 lock.readLock() 和 lock.readUnLock() 之间, lock.readLock() 表示获取用于读取的锁, lock.readUnLock() 表示释放用于读取的锁

public class Data {

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

    public Data(int size) {
        this.buffer = new char[size];
        Arrays.fill(buffer, '*');
    }

    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;
    }

    private void slowly() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            //
        }
    }

    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();
        }
    }
}

      

2.3 WriteThraed类

       WriteThread 类表示的是对 Data 实例执行写入操作的线程, 构造函数的参数 filler 是一个字符串, 程序会逐个取出里面的字符, 并 write 到 data 实例中, 每写入一次, 线程会随机 sleep 几秒

public class WriteThread extends Thread {

    private static final Random r = new Random();
    private final Data data;
    private final String filler;
    private int index = 0;

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

    @Override
    public void run() {
        try {
            while (true) {
                char c = newChar();
                data.write(c);
                Thread.sleep(r.nextInt(3000));
            }
        } catch (InterruptedException e) {
            //
        }
    }

    private char newChar() {
        char c = filler.charAt(index);
        index++;
        if (index >= filler.length()) {
            index = 0;
        }
        return c;
    }
}
2.4 ReadThread类

        ReadThread 表示的是执行读取线程的类, 该类会循环调用 data.read() 方法

public class ReadThread extends Thread {

    private final Data data;

    public ReadThread(Data data) {
        this.data = data;
    }

    @Override
    public void run() {
        try {
            while (true) {
                char[] read = data.read();
                System.out.println(Thread.currentThread().getName() + " reads " + String.valueOf(read));
                Thread.sleep(3000);
            }
        } catch (InterruptedException e) {
            //
        }
    }
}
2.6 ReadWriteLock类 

        该类提供了用于读取的锁和写入的锁, 为了确保安全性, 我们需要防止以下两种冲突 : 

                "读取" 和 "写入" 的冲突

                "写入" 和 "写入" 的冲突

        由于不存在 "读取" 和 "读取" 的冲突, 所以我们无需对其进行考虑

        为了防止发生冲突, 获取用于读取的锁, 和用于写入的锁的条件, 一般存在一下四种情况 :

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

                        如果有线程正在执行写入, 则等待, 否则会引起 "读取" 和 "写入" 的冲突

                        如果有线程正在执行读取, 则无需等待, 因为不存在 "读取" 和 "读取" 的冲突

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

                        如果有线程正在执行写入, 则等待, 否则会引起 "写入" 和 "写入" 的冲突

                        如果有线程正在执行读取, 则等待, 否则会引起 "读取" 和 "写入" 的冲突

        综上所述, 获取获取锁, 只会存在一种冲突, 但是获取写入所, 会存在两种冲突

package cn.demo05;


public class ReadWriteLock {

    private int readingReaders = 0; // 实际正在读取中的线程格式
    private int waitingWrites = 0; // 正在等待写入的线程个数
    private int writingWrites = 0; // 实际正在写入的线程个数
    private boolean preferWriter = true; // 若写入优化, 则为 true

    public synchronized void readLock() throws InterruptedException {
        // 读取时, 若存在正在写入的线程, 或 存在等待写入的线程, 则进入 wait
        while (writingWrites > 0 || (preferWriter && waitingWrites > 0)) {
            wait();
        }
        // 读线程++
        readingReaders++;
    }

    public synchronized void readUnLock() {
        readingReaders--;
        preferWriter = true;
        // 唤醒写线程
        notifyAll();
    }

    public synchronized void writeLock() throws InterruptedException {
        waitingWrites++;
        try {
            // 写入是, 若存在正在读取的线程, 或 实际正在写入的线程, 则进入 wait
            while (readingReaders > 0 || writingWrites > 0) {
                wait();
            }
        } finally {
            waitingWrites--;
        }
        // 写线程++
        writingWrites++;
    }

    public synchronized void writeUnLock() {
        // 写线程--
        writingWrites--;
        preferWriter = false;
        // 唤醒读线程, 或 其他写线程
        notifyAll();
    }
}
2.7 运行示例

        如图所示, 该结果显示的是 ReadThraed 读取的内容, 当 WriteThread 线程写入时, 输出会暂停一下, 另外, 如果线程是不安全的, 那么打印的多个字符会交织在一起显示, (也就是说读取的时候, 有线程执行了写入)

Thread-2 reads aaaaaaaaaa
Thread-4 reads aaaaaaaaaa
Thread-3 reads aaaaaaaaaa
Thread-5 reads aaaaaaaaaa
Thread-1 reads aaaaaaaaaa
Thread-0 reads aaaaaaaaaa
Thread-1 reads AAAAAAAAAA
Thread-4 reads AAAAAAAAAA
Thread-3 reads AAAAAAAAAA
Thread-0 reads AAAAAAAAAA
Thread-2 reads AAAAAAAAAA
三. Read-Write-Lock模式中的登场的角色 3.1 Reader(读者)

        Reader 角色对 SharedResource 角色执行 read 操作, 在示例程序中, 由 ReadThread 类扮演

3.2 Writer(写者)

        Writer 角色对 SharedResource 角色执行 write 操作, 在示例程序中, 由 WriteThread 类扮演

3.3 SharedResource(共享资源)

        SharedResource 角色表示的是 Reader 和 Writer 共享的资源, SharedResource 角色提供不修改内部状态的操作 read() 方法和修改内部状态的操作 write() 方法, 在示例程序中, 有 Data 扮演

3.4 ReadWriteLock(读写锁)

        ReadWriteLock 角色提供了 SharedResource 实现 read() 方法和 write () 方法时所需要的锁, 也就是实现 read() 方法的 readLock 和 readUnLock, 和实现 write() 方法的 writeLock 和writeUnLock, 在示例程序中, 有 ReadWriteLock 类扮演该角色

3.5 模式类图

  

 

四. 使用juc简化ReadWriteLock

        只需要把自己设计的读写锁, 需改为juc包下的 ReentrantReadWriteLock 即可       

package cn.demo05;

import java.util.Arrays;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;


public class Data {

    private final char[] buffer;
//    private final ReadWriteLock lock = new ReadWriteLock();
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    private final Lock readLock = lock.readLock();
    private final Lock writeLock = lock.writeLock();

    public Data(int size) {
        this.buffer = new char[size];
        Arrays.fill(buffer, '*');
    }

    public char[] read() throws InterruptedException {
        // 获取读锁
//        lock.readLock();
        readLock.lock();
        try {
            return doRead();
        } finally {
//            lock.readUnLock();
            readLock.unlock();
        }
    }

    private char[] doRead() {
        char[] newBuf = new char[buffer.length];
        for (int i = 0; i < buffer.length; i++) {
            newBuf[i] = buffer[i];
        }
        slowly();
        return newBuf;
    }

    private void slowly() {
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            //
        }
    }

    public void write(char c) throws InterruptedException {
        // 获取写锁
//        lock.writeLock();
        writeLock.lock();
        try {
            doWrite(c);
        } finally {
//            lock.writeUnLock();
            writeLock.unlock();
        }
    }

    private void doWrite(char c) {
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] = c;
            slowly();
        }
    }
}

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/939357.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号