多线程之读写锁

最新推荐文章于 2024-02-23 17:22:40 发布

原创最新推荐文章于 2024-02-23 17:22:40 发布 · 264 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#多线程 #读写锁

多线程专栏收录该内容

9 篇文章

订阅专栏

本文通过对比分析，展示了使用ReentrantLock和ReentrantReadWriteLock两种方式处理多线程下读写操作的差异。指出在并发读写场景中，简单的ReentrantLock会导致部分线程读取到旧数据的问题。而引入读写锁（ReadWriteLock）机制，能有效确保在写操作发生后，所有读操作均能获取到最新数据，实现读写分离，提高并发效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

先看案例，如下

package hello_java;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReadAndWrite {
    public static void main(String[] args) {
        ShareData04 shareData04 = new ShareData04();
        new Thread(() -> {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            shareData04.write("juc....");
        }).start();

        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                shareData04.read();
            }).start();
        }

    }
}

class ShareData04 {
    private String content;
    Lock lock = new ReentrantLock();

    public String read() {
        lock.lock();
        try {
            System.out.println("Student" + Thread.currentThread().getName() + "get = " + content);
            return content;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        return "";
    }

    public void write(String content) {
        lock.lock();
        try {
            this.content = content;
            System.out.println("The teacher write the content : " + content);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

运行的结果，如下：

StudentThread-1get = null
StudentThread-4get = null
The teacher write the content : juc....
StudentThread-3get = juc....
StudentThread-2get = juc....
StudentThread-5get = juc....
StudentThread-7get = juc....

出现了，有的学生可以读到了数据，有的学生读不到数据的情况。正常的情况应该是，一旦老师修改了数据，所有的学生都应该可以看到数据。为什么会出现这样的现象呢？老师的线程先被启动，但是休眠了两毫秒，在这两毫秒，学生线程有若干被创建，并开始执行，两毫秒到了，老师插进来了，软件是不能这样设计的。

读的时候，不能写即读写分离，写的时候；读和读可以并发，写和写也是互斥的。

解决该问题的方案如下：

package hello_java;

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

public class ReadAndWrite {
    public static void main(String[] args) {
        ShareData04 shareData04 = new ShareData04();
        new Thread(() -> {
            shareData04.write("juc....");
        }).start();

        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                shareData04.read();
            }).start();
        }

    }
}

class ShareData04 {
    private String content;
    private ReadWriteLock lock = new ReentrantReadWriteLock();
    public String read() {
        lock.readLock().lock();
        try {
            System.out.println("Student" + Thread.currentThread().getName() + "get = " + content);
            return content;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.readLock().unlock();
        }
        return "";
    }

    public void write(String content) {
        lock.writeLock().lock();
        try {
            this.content = content;
            System.out.println("The teacher write the content : " + content);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.writeLock().unlock();
        }
    }
}

运行结果如下：

The teacher write the content : juc....
StudentThread-1get = juc....
StudentThread-2get = juc....
StudentThread-4get = juc....
StudentThread-3get = juc....