নেটওয়ার্ক প্রোগ্রামিং প্যাটার্ন — ব্লকিং, নন-ব্লকিং, থ্রেডেড সার্ভার

১ · ব্লকিং I/O — সহজ কিন্তু সীমাবদ্ধ

L35-L36-এ আমরা দেখেছি একটি সার্ভার conn.recv() বা s.recvfrom() কল করে ডেটার জন্য অপেক্ষা করে। এই কলগুলো ডিফল্টভাবে ব্লকিংBlocking I/Oএকটি I/O কল যা ডেটা প্রস্তুত না হওয়া পর্যন্ত প্রোগ্রামের এক্সিকিউশন থামিয়ে রাখে — যতক্ষণ না ডেটা আসে বা connection গ্রহণযোগ্য হয়, ততক্ষণ পরবর্তী লাইন এক্সিকিউট হয় না। — মানে ডেটা না আসা পর্যন্ত প্রোগ্রামের সেই লাইনেই থেমে থাকে, পরের কোনো কাজ করতে পারে না।

এটি single-threaded একটি সার্ভারের জন্য একটি বাস্তব ও গুরুত্বপূর্ণ সীমাবদ্ধতা তৈরি করে — সার্ভার যখন Client A-এর সাথে ব্যস্ত (তার ডেটার জন্য ব্লক করে বসে আছে), তখন সে এমনকি Client B-এর নতুন connection request-টুকুও accept() করতে পারে না, সার্ভ করা তো দূরের কথা। ফলে সব ক্লায়েন্টকে একে একে, সিরিয়ালি সার্ভ করতে হয়।

২ · সমাধান ১ — মাল্টি-থ্রেডেড / মাল্টি-প্রসেস সার্ভার

সবচেয়ে সরাসরি সমাধান — প্রতিটি accept করা connection-এর জন্য একটি নতুন থ্রেড/প্রসেসThread / Processপ্রোগ্রামের একটি স্বতন্ত্র এক্সিকিউশন প্রবাহ, যা মূল প্রোগ্রামের সাথে সমান্তরালে চলতে পারে — প্রতিটি ক্লায়েন্টের জন্য আলাদা থ্রেড/প্রসেস স্পন করলে একটির অপেক্ষা অন্যটিকে ব্লক করে না। স্পন করা। মূল সার্ভার লুপ শুধু নতুন connection accept করেই যায় — প্রতিটি ক্লায়েন্টের প্রকৃত সার্ভিসিং একটি আলাদা থ্রেড/প্রসেসে চলে যায়, যা স্বাধীনভাবে ব্লক হতে পারে অন্যদের প্রভাবিত না করে।

৩ · সমাধান ২ — নন-ব্লকিং / Asynchronous I/O

বড় স্কেলে (একসাথে হাজার হাজার connection) থ্রেড/প্রসেসের ওভারহেড সমস্যা হয়ে দাঁড়ায়। বিকল্প পদ্ধতি — নন-ব্লকিং/asynchronous I/ONon-blocking / Async I/Oএকটি single thread যা একসাথে বহু socket-কে মনিটর করে এবং কোনোটির জন্যই ব্লক না হয়ে শুধু যেগুলোতে ডেটা প্রস্তুত সেগুলো হ্যান্ডেল করে। উদাহরণ: select, epoll, Python-এর asyncio। — যেখানে একটি মাত্র থ্রেড একসাথে বহু socket মনিটর করে, আর যেই socket-এ ডেটা প্রস্তুত হয় শুধু সেটিকেই হ্যান্ডেল করে, কোনোটিতেই না-ব্লক করে বসে না থেকে। Python-এর select মডিউল, লিনাক্সের epoll, এবং উচ্চ-স্তরের asyncio ফ্রেমওয়ার্ক এই মডেলের উদাহরণ (এখানে শুধু নাম উল্লেখ করা হলো, গভীর সিনট্যাক্স নয়)।

এই মডেল প্রোগ্রাম করা তুলনামূলক জটিল (কোড আর সরল সিকোয়েন্সিয়াল লজিকের মতো দেখায় না), কিন্তু থ্রেড/প্রসেসের প্রতি-connection ওভারহেড ছাড়াই অনেক বেশি concurrent connection সামলাতে পারে — বড় স্কেলের ওয়েব সার্ভার (nginx-এর মতো) এই মডেলের উপর ভিত্তি করে তৈরি।

# ব্লকিং বনাম থ্রেডেড সার্ভিসিং — মোট সময়ের সিমুলেশন
# (আসল থ্রেডিং নয় — শুধু দুই মডেলের "মোট সময়" গাণিতিকভাবে তুলনা করা হচ্ছে)

def blocking_server_process(clients, processing_time_per_client):
    """এক-এক করে সার্ভ করা — মোট সময় = সবার processing time-এর যোগফল।"""
    total_time = 0
    log = []
    for name in clients:
        t = processing_time_per_client[name]
        total_time += t
        log.append(f"  {name}: {t}s কাজ শেষ -> মোট এখন পর্যন্ত {total_time}s")
    return total_time, log

def threaded_server_process(clients, processing_time_per_client):
    """সমান্তরালে সার্ভ করা (প্রতি ক্লায়েন্টে এক থ্রেড ধরে নিয়ে) —
    মোট সময় ≈ সবচেয়ে ধীর ক্লায়েন্টের সময়, কারণ সবাই একই সাথে চলে।"""
    times = [processing_time_per_client[name] for name in clients]
    total_time = max(times)
    log = [f"  {name}: {processing_time_per_client[name]}s কাজ (সমান্তরালে চলছে)" for name in clients]
    return total_time, log

clients = ["Client-A", "Client-B", "Client-C", "Client-D"]
processing_time = {"Client-A": 2, "Client-B": 3, "Client-C": 1, "Client-D": 4}

b_total, b_log = blocking_server_process(clients, processing_time)
print("ব্লকিং (এক এক করে):")
print("\n".join(b_log))
print("মোট সময়:", b_total, "সেকেন্ড\n")

t_total, t_log = threaded_server_process(clients, processing_time)
print("থ্রেডেড (সমান্তরালে):")
print("\n".join(t_log))
print("মোট সময়:", t_total, "সেকেন্ড (সবচেয়ে ধীর ক্লায়েন্টের সমান)")

print(f"\nস্পিডআপ: {b_total / t_total:.1f}x")