读者-写者问题

2025 年 4 月 4 日 | 阅读 9 分钟

读者-写者问题是进程同步的经典问题，它涉及到一个文件等数据集，该数据集在同一时间由多个进程共享。在这些不同的进程中，有些是读者——它们只能读取数据集；它们不执行任何更新，有些是写者——它们既可以读取也可以写入数据集。

读者-写者问题用于管理不同读者和写者进程之间的同步，以确保数据集不会出现问题，即不会产生不一致性。

让我们通过一个例子来理解——如果两个或两个以上的读者希望在同一时间访问文件，则不会出现问题。然而，在其他情况下，比如当两个写者或一个读者和一个写者希望在同一时间访问文件时，可能会出现一些问题，因此任务是以这样的方式设计代码：如果一个读者正在阅读，则不允许任何写者在同一时间更新；同样，如果一个写者正在写入，则不允许任何读者在该时间点读取文件；如果一个写者正在更新文件，则不应允许其他写者在同一时间更新文件。但是，多个读者可以同时访问对象。

让我们通过下表了解读写的可能性

表 1

情况	方法 1	方法 2	允许/不允许
情况 1	写作	写作	不允许
情况 2	阅读	写作	不允许
情况 3	写作	阅读	不允许
情况 4	阅读	阅读	允许

读者和写者的解决方案可以使用二值信号量实现。

我们使用两个二值信号量“write”和“mutex”，其中二值信号量可以定义为

信号量：信号量是 S 中的一个整数变量，除了初始化之外，它只能通过两个标准原子操作——wait 和 signal 访问，其定义如下

1. wait( S )
{
while( S <= 0) ;
S--;
}

2. signal( S )
{
S++;
}

从上述 wait 的定义可以清楚地看出，如果 S 的值 <= 0，它将进入无限循环（因为 while 循环后面的分号）。而 signal 的作用是增加 S 的值。

下面的代码将提供读者-写者问题的解决方案，读者和写者进程代码如下 -

读者进程的代码

读者进程的代码如下 -

static int readcount = 0;
wait (mutex);
readcount ++; // on each entry of reader increment readcount
if (readcount == 1)
{
  wait (write);
}
signal(mutex);

--READ THE FILE?

wait(mutex);
readcount --; // on every exit of reader decrement readcount
if (readcount == 0)
{
  signal (write);
}
signal(mutex);

在上述读者代码中，mutex 和 write 是初始值为 1 的信号量，而 readcount 变量的初始值为 0。mutex 和 write 在读者和写者进程代码中是通用的，信号量 mutex 确保互斥，信号量 write 处理写入机制。

readcount 变量表示同时访问文件的读者数量。当变量 readcount 变为 1 时，使用 wait 操作写入信号量，这将使值减 1。这意味着不允许写者再访问文件。完成读取操作后，readcount 减 1。当 readcount 变为 0 时，用于 write 的信号操作允许写者访问文件。

写者进程的代码

定义写者进程的代码如下

wait(write);
WRITE INTO THE FILE
signal(wrt);

如果写者希望访问文件，则对 write 信号量执行 wait 操作，这会将 write 减到 0，并且没有其他写者可以访问文件。当访问文件的写者完成写入工作后，对 write 执行信号操作。

让我们看看表 1 中提到的每个案例的证明

案例 1：写入 - 写入 → 不允许。也就是说，当两个或两个以上进程希望写入时，是不允许的。让我们看看我们的代码是否按此工作？

Explanation :
The initial value of semaphore write = 1
Suppose two processes P0 and P1 wants to write, let P0 enter first the writer code, The moment P0 enters
 Wait( write ); will decrease semaphore write by one, now write = 0
And continue WRITE INTO THE FILE
Now suppose P1 wants to write at the same time (will it be allowed?) let's see.
P1 does Wait( write ), since the write value is already 0, therefore from the definition of wait, it will go into an infinite loop (i.e. Trap), hence P1 can never write anything, till P0 is writing.
Now suppose P0 has finished the task, it will
signal( write); will increase semaphore write by 1, now write = 1
if now P1 wants to write it since semaphore write > 0
This proofs that, if one process is writing, no other process is allowed to write.

案例 2：读取 - 写入 → 不允许。也就是说，当一个或一个以上进程正在读取文件时，不允许其他进程写入。让我们看看我们的代码是否按此工作？

Explanation:
Initial value of semaphore mutex = 1 and variable readcount = 0
Suppose two processes P0 and P1 are in a system, P0 wants to read while P1 wants to write, P0 enter first into the reader code, the moment P0 enters 
Wait( mutex ); will decrease semaphore mutex by 1, now mutex = 0
Increment readcount by 1, now readcount = 1, next
if (readcount == 1)// evaluates to TRUE
{
  wait (write); // decrement write by 1, i.e. write = 0(which   
                   clearly proves that if one or more than one 
                   reader is reading then no writer will be  
                   allowed.
}

signal(mutex); // will increase semaphore mutex by 1, now mutex = 1 i.e. other readers are allowed to enter.

And reader continues to --READ THE FILE?

Suppose now any writer wants to enter into its code then:

As the first reader has executed wait (write); because of which write value is 0, therefore wait(writer); of the writer, code will go into an infinite loop and no writer will be allowed.
This proofs that, if one process is reading, no other process is allowed to write.
Now suppose P0 wants to stop the reading and wanted to exit then
Following sequence of instructions will take place:
wait(mutex); // decrease mutex by 1, i.e. mutex = 0
readcount --; // readcount = 0, i.e. no one is currently reading
if (readcount == 0) // evaluates TRUE
{
  signal (write); // increase write by one, i.e. write = 1 
}
signal(mutex);// increase mutex by one, i.e. mutex = 1

Now if again any writer wants to write, it can do it now, since write > 0

案例 3：写入 -- 读取 → 不允许。也就是说，如果一个进程正在写入文件，则不允许其他进程读取。让我们看看我们的代码是否按此工作？

Explanation:
The initial value of semaphore write = 1
Suppose two processes P0 and P1 are in a system, P0 wants to write while P1 wants to read, P0 enter first into the writer code, The moment P0 enters 
Wait( write ); will decrease semaphore write by 1, now write = 0
And continue WRITE INTO THE FILE
Now suppose P1 wants to read the same time (will it be allowed?) let's see.
P1 enters reader's code
Initial value of semaphore mutex = 1 and variable readcount = 0
Wait( mutex ); will decrease semaphore mutex by 1, now mutex = 0
Increment readcount by 1, now readcount = 1, next
if (readcount == 1)// evaluates to TRUE
{
  wait (write); // since value of write is already 0, hence it 
                   will enter into an infinite loop and will not be  
                   allowed to proceed further (which clearly 
                   proves that if one writer is writing then no  
                   reader will be allowed.
}

The moment writer stops writing and willing to exit then 
This proofs that, if one process is writing, no other process is allowed to read.

The moment writer stops writing and willing to exit then it will execute:
signal( write); will increase semaphore write by 1, now write = 1
if now P1 wants to read it can since semaphore write > 0 

案例 4：读取 - 读取 → 允许。也就是说，当一个进程正在读取文件，而另一个或多个进程希望读取时，它们都被允许，即读取 - 读取不是互斥的。让我们看看我们的代码是否按此工作？

Explanation :
Initial value of semaphore mutex = 1 and variable readcount = 0
Suppose three processes P0, P1 and P2 are in a system, all the three processes P0, P1, and P2 want to read, let P0 enter first into the reader code, the moment P0 enters 
Wait( mutex ); will decrease semaphore mutex by 1, now mutex = 0
Increment readcount by 1, now readcount = 1, next
if (readcount == 1)// evaluates to TRUE
{
  wait (write); // decrement write by 1, i.e. write = 0(which   
                   clearly proves that if one or more than one 
                   reader is reading then no writer will be  
                   allowed.
}

signal(mutex); // will increase semaphore mutex by 1, now mutex = 1 i.e. other readers are allowed to enter.

And P0 continues to --READ THE FILE?

→Now P1 wants to enter the reader code
current value of semaphore mutex = 1 and variable readcount = 1
let P1 enter into the reader code, the moment P1 enters 
Wait( mutex ); will decrease semaphore mutex by 1, now mutex = 0
Increment readcount by 1, now readcount = 2, next
if (readcount == 1)// eval. to False, it will not enter if block

signal(mutex); // will increase semaphore mutex by 1, now mutex = 1 i.e. other readers are allowed to enter.

Now P0 and P1 continues to --READ THE FILE?

→Now P2 wants to enter the reader code
current value of semaphore mutex = 1 and variable readcount = 2
let P2 enter into the reader code, The moment P2 enters 
Wait( mutex ); will decrease semaphore mutex by 1, now mutex = 0
Increment readcount by 1, now readcount = 3, next
if (readcount == 1)// eval. to False, it will not enter if block

signal(mutex); // will increase semaphore mutex by 1, now mutex = 1 i.e. other readers are allowed to enter.

Now P0, P1, and P2 continues to --READ THE FILE?


Suppose now any writer wants to enter into its code then:

As the first reader P0 has executed wait (write); because of which write value is 0, therefore wait(writer); of the writer, code will go into an infinite loop and no writer will be allowed.  

Now suppose P0 wants to come out of system( stop reading) then
wait(mutex); //will decrease semaphore mutex by 1, now mutex = 0
readcount --; // on every exit of reader decrement readcount by 
                 one i.e. readcount = 2

if (readcount == 0)// eval. to FALSE it will not enter if block

signal(mutex); // will increase semaphore mutex by 1, now mutex = 1 i.e. other readers are allowed to exit


→ Now suppose P1 wants to come out of system (stop reading) then
wait(mutex); //will decrease semaphore mutex by 1, now mutex = 0
readcount --; // on every exit of reader decrement readcount by 
                 one i.e. readcount = 1

if (readcount == 0)// eval. to FALSE it will not enter if block

signal(mutex); // will increase semaphore mutex by 1, now mutex = 1 i.e. other readers are allowed to exit

→Now suppose P2 (last process) wants to come out of system (stop reading) then
wait(mutex); //will decrease semaphore mutex by 1, now mutex = 0
readcount --; // on every exit of reader decrement readcount by 
                 one i.e. readcount = 0

if (readcount == 0)// eval. to TRUE it will enter into if block
{
  signal (write); // will increment semaphore write by one, i.e. 
                     now write = 1, since P2 was the last process
                     which was reading, since now it is going out, 
                     so by making write = 1 it is allowing the writer    
                     to write now.
}

signal(mutex); // will increase semaphore mutex by 1, now mutex = 1 


The above explanation proves that if one or more than one processes are willing to read simultaneously then they are allowed.

下一个主题戴尔操作系统

读者-写者问题

读者进程的代码

写者进程的代码

联系信息

关注我们

教程

面试题

在线编译器

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

操作系统

进程管理

同步

死锁

内存管理

文件管理

其他

选择题

读者-写者问题

读者进程的代码

写者进程的代码

相关帖子

Windows 10 操作系统 ISO

操作系统中的交换空间管理

分布式系统中的幽灵死锁

操作系统中的并发

OS 中的冷启动 vs 热启动

Windows 操作系统快捷键

Cinnamon 和 MATE 的区别

操作系统中的 5 状态进程模型

操作系统中的访问令牌是什么？

fork() vs vfork()

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器