মনিটর ও উচ্চ-স্তরের সিনক্রোনাইজেশন কনস্ট্রাক্ট

১ · সেমাফোরের আসল সমস্যাটা কী

L18-L21-এ আমরা সেমাফোর দিয়ে ক্রিটিক্যাল সেকশন, প্রডিউসার-কনজিউমার, রিডার্স-রাইটার্স ও ডাইনিং ফিলোসফার্স সমাধান করেছি। প্রতিটি ক্ষেত্রেই সমাধান কাজ করেছে — কিন্তু একটি লুকানো শর্তে: প্রোগ্রামারকে প্রতিটি শেয়ার্ড ডেটা অ্যাক্সেসের আগে-পরে সঠিক ক্রমে ঠিক wait()/signal() কল বসাতে হয়েছে। একটি বড় কোডবেসে, যেখানে শত শত জায়গায় শেয়ার্ড ডেটা অ্যাক্সেস হয়, একটিমাত্র ভুলে-বসানো বা ভুলে-যাওয়া কল —

• একটি signal() ভুলে বাদ পড়লে অন্য সব প্রসেস চিরকালের জন্য আটকে যেতে পারে,
• দুটি wait() ভুল ক্রমে বসালে ডেডলক হতে পারে (M6-এ বিস্তারিত),
• কোনো একটি অ্যাক্সেস পয়েন্টে wait()/signal() বসাতেই ভুলে গেলে চুপচাপ একটি রেস কন্ডিশন থেকে যায় — কম্পাইলার বা রানটাইম কোনো সতর্কতা দেয় না।

২ · মনিটর কী

মনিটর (Monitor)Monitorএকটি উচ্চ-স্তরের সিনক্রোনাইজেশন কনস্ট্রাক্ট যা শেয়ার্ড ডেটা ও তার উপর কাজ করা প্রসিডিওরগুলোকে একসাথে বান্ডেল করে, এবং নিশ্চিত করে একসময়ে কেবল একটি প্রসেস/থ্রেড মনিটরের ভেতরে সক্রিয় থাকতে পারবে। হলো একটি প্রোগ্রামিং-ভাষা-সমর্থিত কনস্ট্রাক্ট যা শেয়ার্ড ডেটা এবং সেই ডেটার উপর কাজ করা প্রসিডিওরগুলোকে একসাথে একটি একক ইউনিটে আবদ্ধ করে। মূল গ্যারান্টি: একসময়ে কেবলমাত্র একটি প্রসেস/থ্রেড মনিটরের ভেতরে সক্রিয়ভাবে চলতে পারবে — এই মিউচুয়াল এক্সক্লুশন প্রোগ্রামার নিজে বসায় না, ভাষা বা রানটাইম নিজেই স্বয়ংক্রিয়ভাবে বলবৎ করে। ফলে সেমাফোরের মতো "প্রতিটি জায়গায় সঠিক ক্রমে wait/signal বসিয়েছি তো?" প্রশ্নটাই আর থাকে না।

৩ · কন্ডিশন ভেরিয়েবল

মনিটরের ভেতরে ঢুকেই যদি কোনো প্রসেস দেখে তার দরকারি শর্ত এখনো সত্যি নয় (যেমন বাফার খালি, তাই consume করার কিছু নেই), তাকে কিছু একটা করতে হবে — কিন্তু মনিটরের ভেতরে বসেই অপেক্ষা করলে অন্য কেউ (যে ঐ শর্ত পূরণ করতে পারত) মনিটরে ঢুকতেই পারবে না, ফলে ডেডলক। এই সমস্যার সমাধান কন্ডিশন ভেরিয়েবল (Condition Variable)Condition Variableমনিটরের ভেতরে থাকা একটি প্রসেসকে মনিটরের লক সাময়িকভাবে ছেড়ে দিয়ে অপেক্ষায় পাঠানোর প্রক্রিয়া (wait), এবং শর্ত পূরণ হলে কাউকে জাগানোর প্রক্রিয়া (signal) — সেমাফোরের wait()/signal() থেকে ভিন্ন একটি মেকানিজম। — এটি একটি প্রসেসকে মনিটরের লক সাময়িকভাবে ছেড়ে দিয়ে অপেক্ষায় পাঠাতে দেয় (wait()), যাতে অন্যরা ভেতরে ঢুকে শর্তটি পূরণ করতে পারে; শর্ত পূরণ হলে অপেক্ষমাণ কাউকে জাগানো হয় (signal()/ notify()), যে তখন লক পুনরায় নিয়ে চালিয়ে যায়। এটি সেমাফোরের wait()/signal() থেকে ভিন্ন — সেমাফোরের wait() মনিটরের কোনো লক ছাড়ে না, কারণ সেমাফোরে "মনিটর" ধারণাটাই নেই।

৪ · একটি মনিটর-স্টাইল bounded buffer

নিচে L19-এর 3-সেমাফোর প্রডিউসার-কনজিউমার সমাধানের বিপরীতে একটি "মনিটর-স্টাইল" bounded buffer দেখানো হলো — এখানেও বাস্তব থ্রেড নয়, শুধুই একটি ইন-মেমরি লক-সিমুলেশন (SimulatedLock) যা দেখায় মনিটরের মূল ধারণা: caller নিজে কখনো লক অ্যাকোয়ার/রিলিজ করছে না — একটি ডেকোরেটর প্রতিটি পাবলিক মেথডের শুরুতে-শেষে স্বয়ংক্রিয়ভাবে তা করছে।

# সিমুলেটেড মনিটর -- বাস্তব থ্রেড/লক নয়, শুধুই একটি ইন-মেমরি লক-সিমুলেশন ধারণা বোঝানোর জন্য

class SimulatedLock:
    def __init__(self):
        self.locked = False

    def acquire(self):
        if self.locked:
            raise RuntimeError("লক ইতিমধ্যে ধরা আছে -- মনিটরের ভেতরে একসাথে দুইজন ঢুকতে পারবে না")
        self.locked = True

    def release(self):
        self.locked = False


def synchronized(method):
    """ডেকোরেটর -- মেথড কল হওয়ার আগে স্বয়ংক্রিয়ভাবে লক অ্যাকোয়ার করে, শেষে রিলিজ করে।
    caller-কে ম্যানুয়ালি wait()/signal() লিখতে হয় না -- এটাই মনিটরের মূল সুবিধা।"""
    def wrapper(self, *args, **kwargs):
        self._lock.acquire()
        try:
            result = method(self, *args, **kwargs)
        finally:
            self._lock.release()
        return result
    return wrapper


class MonitorBoundedBuffer:
    """L19-এর মতোই একটি bounded buffer -- কিন্তু caller-কে মিউটেক্স/সেমাফোর
    ম্যানুয়ালি সামলাতে হয় না; মনিটর (এই ক্লাস) নিজেই তা সামলায়।"""
    def __init__(self, capacity):
        self.capacity = capacity
        self.buffer = []
        self._lock = SimulatedLock()

    @synchronized
    def produce(self, item):
        if len(self.buffer) >= self.capacity:
            return f"বাফার পূর্ণ -> {item} প্রত্যাখ্যাত (বাস্তব মনিটরে এখানে condition variable-এ wait() করা হতো)"
        self.buffer.append(item)
        return f"{item} যোগ হলো -> বাফার এখন {self.buffer}"

    @synchronized
    def consume(self):
        if not self.buffer:
            return "বাফার খালি -> consume করার কিছু নেই (বাস্তব মনিটরে এখানে wait() করা হতো)"
        item = self.buffer.pop(0)
        return f"{item} নেওয়া হলো -> বাফার এখন {self.buffer}"


buf = MonitorBoundedBuffer(capacity=2)
print(buf.produce("A"))
print(buf.produce("B"))
print(buf.produce("C"))   # পূর্ণ -- caller কোনো সেমাফোর ছাড়াই নিরাপদ প্রত্যাখ্যান পেলো
print(buf.consume())
print(buf.produce("C"))   # এখন জায়গা খালি হয়েছে
print(buf.consume())
print(buf.consume())
print(buf.consume())      # খালি

print("\n--- রিএন্ট্র্যান্সি সমস্যা (একটি বাস্তব মনিটর-সাবধানতা) ---")

class BuggyMonitor(MonitorBoundedBuffer):
    @synchronized
    def produce_two(self, item1, item2):
        # ভুল করে একই অবজেক্টের আরেকটি synchronized মেথড ভেতর থেকে কল করা হলো
        self.produce(item1)
        self.produce(item2)

buggy = BuggyMonitor(capacity=5)
try:
    buggy.produce_two("X", "Y")
except RuntimeError as e:
    print("ত্রুটি ধরা পড়লো:", e)