Readers Writers Problem in Java Using Threads

2025年5月2日 | 阅读 4 分钟

读者-写者问题是计算机科学教育中的另一个并发控制问题，其中多个进程（或线程）尝试访问共享资源。在这种情况下，读者只需读取数据，而写者可以更改数据。

任务是提供多读者并发性，同时，写者需要资源对其他人关闭。这个问题模拟了这种情况，例如所有工作人员都使用数据库进行读取，而只有一名工作人员一次写入。

这里的问题是应用程序的变体同时读取和更改数据，导致数据竞争条件等负面影响。

文件名：ReadersWritersProblem.java

import java.util.concurrent.locks.ReentrantReadWriteLock;
// Shared resource class
class SharedResource {
    private int data = 0;  // Shared data
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    // Method for reading data
    public void readData(String readerName) {
        rwLock.readLock().lock();  // Acquire read lock
        try {
            System.out.println(readerName + " is reading data: " + data);
            Thread.sleep(1000);  // Simulate read time
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            rwLock.readLock().unlock();  // Release read lock
        }
    }
    // Method for writing data
    public void writeData(String writerName, int newData) {
        rwLock.writeLock().lock();  // Acquire write lock
        try {
            System.out.println(writerName + " is writing data: " + newData);
            Thread.sleep(1000);  // Simulate write time
            this.data = newData;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            rwLock.writeLock().unlock();  // Release write lock
        }
    }
}
// Reader thread class
class Reader extends Thread {
    private final SharedResource sharedResource;
    private final String readerName;
    public Reader(SharedResource sharedResource, String readerName) {
        this.sharedResource = sharedResource;
        this.readerName = readerName;
    }
    @Override
    public void run() {
        while (true) {
            sharedResource.readData(readerName);  // Perform read operation
            try {
                Thread.sleep(2000);  // Sleep between reads
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
// Writer thread class
class Writer extends Thread {
    private final SharedResource sharedResource;
    private final String writerName;
    public Writer(SharedResource sharedResource, String writerName) {
        this.sharedResource = sharedResource;
        this.writerName = writerName;
    }
    @Override
    public void run() {
        int newData = 1;
        while (true) {
            sharedResource.writeData(writerName, newData++);  // Perform write operation
            try {
                Thread.sleep(3000);  // Sleep between writes
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class ReadersWritersProblem {
    public static void main(String[] args) {
        SharedResource sharedResource = new SharedResource();
        // Create and start multiple readers
        Reader reader1 = new Reader(sharedResource, "Reader 1");
        Reader reader2 = new Reader(sharedResource, "Reader 2");
        reader1.start();
        reader2.start();
        // Create and start multiple writers
        Writer writer1 = new Writer(sharedResource, "Writer 1");
        Writer writer2 = new Writer(sharedResource, "Writer 2");
        writer1.start();
        writer2.start();
    }
}   

输出

 
Reader 2 is reading data: 0
Reader 1 is reading data: 0
Writer 2 is writing data: 1
Writer 1 is writing data: 1
Reader 2 is reading data: 1
Reader 1 is reading data: 1
Writer 2 is writing data: 2
Writer 1 is writing data: 2
Reader 2 is reading data: 2
Reader 1 is reading data: 2
Writer 2 is writing data: 3
Writer 1 is writing data: 3
Reader 2 is reading data: 3
Reader 1 is reading data: 3
Writer 2 is writing data: 4
Writer 1 is writing data: 4
Reader 2 is reading data: 4…………

解释

SharedResource 类：此类包含共享资源，即整数数据和 ReentrantReadWriteLock。它有两个方法
readData()：获取读锁，执行读取操作，然后释放锁。
writeData()：锁定写节点；然后，模拟写入新值；最后，释放节点。
Reader 类：此类也扩展了 Thread，并模拟了一个试图永久读取共享数据的读者线程。它调用 SharedResource 类的 readData() 方法。
Writer 类：此类也扩展了 Thread，并模拟了一个不断写入共享数据的写者线程。它调用 writeData() 过程来更改共享资源。

结论

在本文所描述的读者-写者问题实现中，Java 的使用上下文是，线程被用作共享信息的读者和写者。

因此，通过 ReentrantReadWriteLock，我们保证了可以进行多次读取操作而不会受到其他线程的干扰，同时最多只能进行一次写入操作，这将使我们的应用程序成为线程安全的。

这种方法有效地说明了在并发编程中协调进程以避免操作之间的干扰的必要性。

下一主题Java 中的最高优先级

Readers Writers Problem in Java Using Threads

解释

结论

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Readers Writers Problem in Java Using Threads

解释

结论

相关帖子

Java File Upload to a Folder

Java 中原始数据类型和非原始数据类型之间的区别

Java 10 var 关键字

How to Generate Random Number in Java

Java 中的链式异常

How does the 'accessOrder' Configuration in LinkedHashMap Work in Java?

Xylem and Phloem Number in Java

Highest precedence in Java

Java 中返回多个值

How to Compare Dates in Java

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器