ক্লাসিক সিনক্রোনাইজেশন: রিডার্স-রাইটার্স

class Semaphore:  # L18-এর ক্লাস, অপরিবর্তিত
    def __init__(self, initial_value):
        self.value = initial_value
        self.waiting = []

    def wait(self, name):
        self.value -= 1
        if self.value < 0:
            self.waiting.append(name)
            print(f"    {name}: wait() -> value={self.value} (BLOCKED, waiting={self.waiting})")
            return False
        print(f"    {name}: wait() -> value={self.value} (proceed)")
        return True

    def signal(self, name):
        self.value += 1
        woken = None
        if self.value <= 0 and self.waiting:
            woken = self.waiting.pop(0)
            print(f"    {name}: signal() -> value={self.value} (wakes {woken})")
        else:
            print(f"    {name}: signal() -> value={self.value}")
        return woken


reader_count = 0
mutex = Semaphore(1)          # reader_count প্রোটেক্ট করে
resource_lock = Semaphore(1)  # প্রকৃত শেয়ার্ড রিসোর্স
shared_data = "v1"
pending_writer = [None]

def start_read(name):
    global reader_count
    print(f"\n{name}: start_read()")
    mutex.wait(name)
    reader_count += 1
    print(f"    reader_count = {reader_count}")
    if reader_count == 1:
        print("    প্রথম রিডার -> resource_lock acquire")
        resource_lock.wait(name)
    mutex.signal(name)

def end_read(name):
    global reader_count
    print(f"\n{name}: end_read()")
    mutex.wait(name)
    reader_count -= 1
    print(f"    reader_count = {reader_count}")
    if reader_count == 0:
        print("    শেষ রিডার -> resource_lock release")
        woken = resource_lock.signal(name)
        if woken:
            resume_writer_after_wakeup()
    else:
        mutex.signal(name)
        return
    mutex.signal(name)

def write(name, new_value):
    global shared_data
    print(f"\n{name}: write('{new_value}') চেষ্টা")
    ok = resource_lock.wait(name)
    if not ok:
        pending_writer[0] = (name, new_value)
        print(f"    {name} blocked -- resource ফ্রি না হওয়া পর্যন্ত অপেক্ষা")
        return
    shared_data = new_value
    print(f"    shared_data আপডেট হলো -> {shared_data}")
    resource_lock.signal(name)

def resume_writer_after_wakeup():
    global shared_data
    name, new_value = pending_writer[0]
    print(f"  [ব্লকড writer {name} এখন জাগ্রত]")
    shared_data = new_value
    print(f"    shared_data আপডেট হলো -> {shared_data}")
    resource_lock.signal(name)


start_read("Reader1")
start_read("Reader2")   # Reader1-এর সাথে ওভারল্যাপ -- অতিরিক্ত ব্লকিং নেই
print(f"\nএখন একসাথে active reader_count = {reader_count} (দুইজন রিডার একসাথে পড়ছে)")

write("Writer1", "v2")   # resource_lock রিডারদের দখলে -- BLOCKED হবে

end_read("Reader1")      # reader_count=1, এখনো Reader2 active, resource_lock ছাড়বে না
end_read("Reader2")      # last reader -- resource_lock release, Writer1 জাগ্রত হবে

print("\nফাইনাল shared_data:", shared_data)
print("ফাইনাল reader_count:", reader_count)
print("ফাইনাল resource_lock.value:", resource_lock.value)