python

import threading

import time

import random

# Constants for the number of writers, editors, and available review slots

NUM$\_$WRITERS $=5$ # Number of writers to simulate

NUM$\_$EDITORS $=2$ # Number of editors to simulate

NUM$\_$SLOTS $=3$ # Maximum simultaneous reviews

# Semaphore to manage available review slots

review$\_$slots $=$ threading.Semaphore$($NUM$\_$SLOTS$)$

# Lock to ensure one editor reviews an article at a time

editor$\_$lock $=$ threading.Lock$()$

# Lock to prevent overlapping print output

print$\_$lock $=$ threading.Lock$()$

# Shared variables to track the submission and review process

articles$\_$submitted $=0$ # Number of articles submitted

TOTAL$\_$ARTICLES $=$ NUM$\_$WRITERS # Total articles expected

# Event to signal that all articles are reviewed

stop$\_$editors $=$ threading.Event$()$

def writer$\_$task$($writer$\_$id$)$:

$"""$Simulates a writer drafting and submitting an article."""

with print$\_$lock:

print$($f$"$Writer $\{$writer$\_$id$\}$ is drafting an article."$)$

# Simulate drafting time

time.sleep$($random$.$uniform$(1,2))$

with print$\_$lock: # console is a shared resource, so we need to lock it

print$($f$"$Writer $\{$writer$\_$id$\}$ is waiting for a review slot."$)$

# TODO $1$: Acquire the review slot before submission

with print$\_$lock: # console is a shared resource, so we need to lock it

print$($f$"$Writer $\{$writer$\_$id$\}$ has submitted an article for review."$)$

# TODO $2$: Safely update the shared variable $`$articles$\_$submitted$`$ tracking the number of submitted articles

# TODO $3$: Release the review slot after submission

def editor$\_$task$($editor$\_$id$)$:

$"""$Simulates an editor reviewing articles."""

while not stop$\_$editors.is$\_$set$()$:

# Simulate the time before checking for an article

time.sleep$($random$.$uniform$(0\mathrm{.}5,1\mathrm{.}5))$

with print$\_$lock: # console is a shared resource, so we need to lock it

print$($f$"$Editor $\{$editor$\_$id$\}$ is checking for an article to review."$)$

# TODO $4$: Acquire the editor lock with a timeout to avoid deadlock

try:

# TODO $5$: Check if there are articles to review

with print$\_$lock: # console is a shared resource, so we need to lock it

print$($f$"$Editor $\{$editor$\_$id$\}$ is reviewing an article."$)$

time.sleep$($random$.$uniform$(1,3))$ # Simulate review time

with print$\_$lock: # console is a shared resource, so we need to lock it

print$($f$"$Editor $\{$editor$\_$id$\}$ has finished reviewing an article."$)$

# TODO $7$: Safely decrement the number of submitted articles

# TODO $8$: Stop editors if all articles are reviewed

finally:

# TODO $9$: Ensure the editor lock is released

pass # TODO $10$: Remove this line after adding the code

with print$\_$lock:

print$($f$"$Editor $\{$editor$\_$id$\}$ is stopping as all reviews are complete."$)$

def main$()$:

$"""$Main function to initialize the simulation."""

writer$\_$threads $=[]$

for i in range$($NUM$\_$WRITERS$)$:

t $=$ threading.Thread$($target$=$writer$\_$task, args$=($i$,))$

writer$\_$threads.append$($t$)$

t$.$start$()$

editor$\_$threads $=[]$

for i in range$($NUM$\_$EDITORS$)$:

t $=$ threading.Thread$($target$=$editor$\_$task, args$=($i$,))$

editor$\_$threads.append$($t$)$

t$.$start$()$

for t in writer$\_$threads:

t$.$join$()$

for t in editor$\_$threads:

t$.$join$()$

print$("$All articles have been submitted and reviewed."$)$

if $\_\_$name$\_\_=="\_\_$main$\_\_"$:

main$()$