এই পর্বে যা শিখবেন
- Concurrency-র bug কেন সাধারণ test-এ ধরা পড়ে না: non-determinism, interleaving আর heisenbug
- Bug-এর পরিবার: race condition, data race, atomicity violation, check-then-act, TOCTOU, deadlock আর livelock
- তিনটি test কৌশল: সব interleaving গোনা, barrier-ভিত্তিক stress test, আর timeout দিয়ে আটকে যাওয়া ধরা
- Async কোডের test: pytest-asyncio, event loop-এর determinism আর
asyncio.Lock - একসাথে অনেক অনুরোধে idempotency আর database-এর সুরক্ষা যাচাই, বাজারঘরের API-তে
১ · একই কোড, ভিন্ন ক্রম — কেন concurrency-র bug ধরা কঠিন
ঈদের আগে রাতের বাসের টিকিট কাউন্টারের কথা ভাবুন। একটি বাসে শেষ একটি আসন বাকি। দুটি কাউন্টারে দুজন বিক্রেতা একই খাতা দেখেন। প্রথমজন খাতায় দেখলেন “১টি খালি”, ক্রেতার কাছে টাকা নিতে মুখ ফেরালেন। ঠিক তখন দ্বিতীয়জনও খাতা দেখলেন: “১টি খালি”। দুজনেই টিকিট কাটলেন, দুজনেই খাতায় দাগ দিলেন। রাতে বাসে একটি আসনে দুজন যাত্রী। কোনো বিক্রেতা ভুল হিসাব করেননি; ভুলটি দুজনের কাজের ধাপ মিশে যাওয়ায়। আর প্রতিদিন এমন হয় না: শুধু সেই দিন, যেদিন দুজন একই কয়েক সেকেন্ডের মধ্যে খাতা দেখেন।
সফটওয়্যারে এই ঘটনার নাম race condition: ফল নির্ভর করছে কয়েকটি কাজ কোন ক্রমে বা কত দ্রুত ঘটল তার ওপর। এখানে thread মানে একটি program-এর ভেতরে একসাথে চলা কাজের ধারা; web server-এ প্রতিটি অনুরোধ সাধারণত আলাদা thread বা আলাদা কাজ হিসেবে চলে। দুই অনুরোধের ধাপগুলো কোন ক্রমে মিশবে, তা ঠিক করে operating system-এর scheduler, network-এর দেরি আর CPU-র ব্যস্ততা। Test সেই ক্রম ঠিক করে না। ফলে তিনটি সমস্যা:
- Non-determinism: একই test, একই কোড, ভিন্ন ফল। পর্ব ৪০-এ দেখেছেন, flaky test-এর গবেষণায় concurrency একটি বড় কারণ; কিন্তু সেখানে প্রশ্ন ছিল “test-এর দোষ না product-এর?” এই পর্বে product-এর দিক: কোডে সত্যিকারের race থাকলে কীভাবে তা ইচ্ছা করে, পুনরুৎপাদনযোগ্যভাবে দেখাবেন।
- বিরলতা: ভুলটি শুধু একটি সরু সময়-জানালায় ঘটে। Developer-এর কম্পিউটারে একা চালালে প্রায় কখনো না; ঈদের sale-এর রাতে হাজার ক্রেতার চাপে বারবার।
- দেখলেই লুকায়:
printবা debugger বসালে সময় বদলে যায়, আর জানালাটি বন্ধ হয়ে যায়। এমন bug-কে মজা করে heisenbug বলা হয়, পদার্থবিজ্ঞানের Heisenberg-এর নামে: মাপতে গেলেই অবস্থা বদলায়।
তাহলে tester কী করবেন? মূল কৌশল একটিই: ক্রমকে ভাগ্যের হাতে না ছেড়ে নিজের হাতে নেওয়া। হয় সব সম্ভাব্য ক্রম গুনে প্রতিটি চালাবেন (§৩), নয়তো সবাইকে ঠিক একই মুহূর্তে ছেড়ে দিয়ে জানালাটি বড় করবেন (§৪, §৫), নয়তো সময় আর scheduler-কে test-এর নিয়ন্ত্রণে আনবেন (§৭)। আগে দেখে নিন কোন কোন ধরনের ভুল খুঁজছেন।
আগে কোথায় দেখেছেন: অপারেটিং সিস্টেম কোর্সের পর্ব ২২ (race condition আর critical section) আর পর্ব ২৭ (deadlock) ভেতরের যন্ত্রটি শেখায়; পাইথন প্রোগ্রামিং কোর্সের পর্ব ৪৪ (thread আর GIL) আর পর্ব ৪৫ (asyncio) ভাষার দিক। এই কোর্সের পর্ব ৩৩-এ দুই connection-এর lost update একটি নির্দিষ্ট ক্রমে দেখেছেন। এখানে সেগুলো আবার শেখানো হবে না; প্রশ্ন একটিই: এমন ভুল test দিয়ে কীভাবে ধরবেন, আর ঠিক হলো কি না কীভাবে প্রমাণ করবেন।
২ · ভুলের পরিবার — কী খুঁজছেন
সব concurrency-র ভুল দেখতে এক নয়, আর প্রতিটির জন্য test-এর প্রশ্নও আলাদা। নিচের টেবিলে প্রতিটির একটি বাজারঘর-উদাহরণ।
| ধরন | কী ঘটে | বাজারঘরে | Test-এর প্রশ্ন |
|---|---|---|---|
| Data race | দুই thread একই memory একসাথে ছোঁয়, অন্তত একটি লেখে, মাঝে কোনো lock নেই | দুই thread একটি Python object-এর stock field একসাথে বদলায় | Shared data-য় প্রতিটি লেখা কি পাহারায়? |
| Check-then-act | শর্ত দেখা আর সেই অনুযায়ী কাজের মাঝে অবস্থা বদলে যায় | “স্টক ≥ ১?” দেখে, তারপর কমানো | দেখা আর করা কি একটি অবিভাজ্য ধাপ? |
| Atomicity violation | যে কয়েকটি ধাপ একসাথে হওয়ার কথা, তার মাঝে অন্য কাজ ঢোকে | অর্ডার লেখা হলো, স্টক কমার আগেই আরেকটি অর্ডার | অর্ধেক-করা অবস্থা কি অন্যের চোখে পড়ে? |
| Lost update | দুজন পুরোনো মান পড়ে লেখে, একটির লেখা হারায় | admin-এর স্টক পাতা (পর্ব ৩৩) | শেষ মান কি সব বদলের যোগফল? |
| TOCTOU | যাচাইয়ের সময় আর ব্যবহারের সময়ের মাঝে জিনিসটি বদলায় | coupon “এখনো বৈধ” দেখে, চেকআউটের মুহূর্তে মেয়াদ শেষ | ব্যবহারের মুহূর্তে কি আবার যাচাই হয়? |
| Deadlock | দুজন একে অপরের হাতের lock-এর জন্য চিরকাল অপেক্ষা | চেকআউট আগে স্টক, পরে wallet ধরে; refund উল্টো ক্রমে | নির্দিষ্ট সময়ে কাজ শেষ হয় কি? |
| Livelock | সবাই ব্যস্ত, বারবার চেষ্টা করছে, কিন্তু কেউ এগোয় না | দুই retry একই সময়ে পিছিয়ে আবার একই সময়ে চেষ্টা | অগ্রগতি হচ্ছে, না শুধু ব্যস্ততা? |
দুটি পার্থক্য পরীক্ষায় প্রায়ই আসে। প্রথমত, data race আর race condition এক নয়। Data race একটি নিচু স্তরের সংজ্ঞা: lock ছাড়া একই memory-তে একসাথে লেখা। Race condition উঁচু স্তরের: ফল ক্রমের ওপর নির্ভর করে। একটি ছাড়া অন্যটি থাকতে পারে, আর tester-এর জন্য জরুরি দিকটি হলো data race ছাড়াও race condition: প্রতিটি আলাদা ধাপ lock দিয়ে পাহারা দিলেও check-then-act ভুল থাকতে পারে, কারণ দুই ধাপের মাঝখানে lock নেই। একে কখনো logical race বলা হয়। বাজারঘরের HTTP-স্তরের সব ভুল এই ধরনের: প্রতিটি SQL statement নিজে নিরাপদ, তবু দুই অনুরোধের মিশ্রণে ভুল।
দ্বিতীয়ত, TOCTOU (time-of-check to time-of-use) check-then-act-এরই একটি নাম, যা নিরাপত্তার জগতে বেশি চলে: কোনো ফাইলের অনুমতি যাচাই করে, তারপর খোলার আগে কেউ ফাইলটি বদলে দিল। নিরাপত্তার দিকটি সাইবার সিকিউরিটি কোর্সের বিষয়; tester-এর প্রশ্নটি একই: “যাচাই আর ব্যবহারের মাঝে কতটা ফাঁক, আর সেই ফাঁকে কে ঢুকতে পারে?”
৩ · সব ক্রম গুনে দেখা — interleaving explorer
সবচেয়ে সরল কিন্তু শক্তিশালী কৌশল: কাজগুলোকে ছোট ধাপে ভাগ করুন, তারপর সম্ভাব্য প্রতিটি ক্রমে চালান। ধরুন দুধের শেষ ১টি প্যাকেট আছে, দুজন ক্রেতা A আর B. প্রতিজনের তিন ধাপ: read (স্টক পড়া), check (≥ ১ কি না), act (স্টক কমানো আর বিক্রি লেখা)। একজনের ধাপের নিজস্ব ক্রম বদলায় না, কিন্তু দুজনের ধাপ যেকোনোভাবে মিশতে পারে। ছয়টি জায়গার কোন তিনটিতে A বসবে, তা বাছার উপায় ৬C৩ = ২০, অর্থাৎ ২০টি interleaving.
প্রথমে একটি ক্রম ধাপে ধাপে দেখুন, যেখানে দুজনেই পালা করে চলেন (A, B, A, B, A, B):
| এই ধাপ | |
| A দেখেছে | |
| B দেখেছে | |
| stock | |
| sold |
- A পড়ে। A স্টক পড়ে: ১। এখনো কিছু বদলায়নি।
- B পড়ে। A কিছু করার আগেই B-ও পড়ে: ১। দুজনের মাথায় এখন একই পুরোনো সংখ্যা।
- A যাচাই করে। ১ ≥ ১, তাই A-র সিদ্ধান্ত: কেনা যাবে।
- B যাচাই করে। B-ও নিজের পড়া ১ দেখে একই সিদ্ধান্ত নেয়। এখানেই ভুল ঘটে গেছে, যদিও এখনো কিছু লেখা হয়নি।
- A কেনে। স্টক ০, বিক্রি ১। এ পর্যন্ত সব ঠিক দেখায়।
- B কেনে। স্টক −১, বিক্রি ২: একটি প্যাকেট দুজনের কাছে বিক্রি (oversell). B-র যাচাই ছিল সঠিক, কিন্তু পুরোনো তথ্যে।
- সব ক্রমের ফল। নিচের কোড ২০টি ক্রমই চালায়। শুধু AAABBB আর BBBAAA নিরাপদ, যেখানে একজন পুরো কাজ শেষ করার পরে অন্যজন পড়েন। বাকি ১৮টিতে বিক্রি ২।
নিচের ছবিতে একই ক্রমটি সময়ের দিকে নিচে নামছে। মাঝের কলামে প্রতিটি ধাপের পরে স্টক:
Check-then-act race — শেষ ১টি প্যাকেট, দুজন ক্রেতা
Interleaving A, B, A, B, A, B: both read 1 before anyone writes
এবার ২০টি ক্রমই চালিয়ে দেখুন, একটি আসল unittest suite হিসেবে। প্রতিটি ধাপ একটি ছোট function; explorer ঠিক করে কে কখন এগোবে। দ্বিতীয় test-এ একই তিন ধাপ একটি lock-এর ভেতরে, অর্থাৎ একটি অবিভাজ্য ধাপ। “চালান” চাপুন; প্রথমবার ব্রাউজারে Python (Pyodide) নামতে কয়েক সেকেন্ড লাগে।
import itertools, sys, unittest
def buyer(atomic): # one buyer's steps on the shared shop
def read(shop, me): me["seen"] = shop["stock"]
def check(shop, me): me["ok"] = me["seen"] >= 1
def act(shop, me):
if me["ok"]:
shop["stock"] -= 1
shop["sold"] += 1
def locked(shop, me): read(shop, me); check(shop, me); act(shop, me)
return [locked] if atomic else [read, check, act]
def explore(atomic, stock=1): # run EVERY interleaving of A and B
steps = {"A": buyer(atomic), "B": buyer(atomic)}
n, bad, total = len(steps["A"]), [], 0
for slots in itertools.combinations(range(2 * n), n):
order = ["A" if i in slots else "B" for i in range(2 * n)]
shop, me, pc = {"stock": stock, "sold": 0}, {"A": {}, "B": {}}, {"A": 0, "B": 0}
for who in order:
steps[who][pc[who]](shop, me[who])
pc[who] += 1
total += 1
if shop["sold"] > stock:
bad.append("".join(order))
print(f"\n {total} schedules, {len(bad)} oversell, e.g. {bad[:3]}")
return bad
class LastPacket(unittest.TestCase):
def test_locked(self):
self.assertEqual(len(explore(atomic=True)), 0)
def test_split(self):
self.assertEqual(len(explore(atomic=False)), 0)
suite = unittest.defaultTestLoader.loadTestsFromTestCase(LastPacket)
unittest.TextTestRunner(stream=sys.stdout, verbosity=2).run(suite)আসল আউটপুট (ব্রাউজারের Python):
test_locked (__main__.LastPacket.test_locked) ...
2 schedules, 0 oversell, e.g. []
ok
test_split (__main__.LastPacket.test_split) ...
20 schedules, 18 oversell, e.g. ['AABABB', 'AABBAB', 'AABBBA']
FAIL
======================================================================
FAIL: test_split (__main__.LastPacket.test_split)
----------------------------------------------------------------------
Traceback (most recent call last):
File "main.py", line 32, in test_split
self.assertEqual(len(explore(atomic=False)), 0)
~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
AssertionError: 18 != 0
----------------------------------------------------------------------
Ran 2 tests in 0.003s
FAILED (failures=1)
Lock-সহ সংস্করণে প্রতিজনের একটিই ধাপ, তাই মাত্র ২টি ক্রম (AB আর BA), আর কোনোটিতে বেশি বিক্রি নেই: test সবুজ। ভাগ করা সংস্করণে ২০টির ১৮টিতে oversell, আর test লাল, প্রথম তিনটি খারাপ ক্রমের নামসহ। এই সংখ্যা দেখে ভাববেন না যে বাস্তবে ৯০% সময় ভুল হয়। বাস্তবে একজনের তিনটি ধাপ কয়েক microsecond-এ শেষ হয়, আর scheduler সাধারণত মাঝখানে থামায় না; তাই AAABBB ধরনের ক্রমই বেশিরভাগ সময় ঘটে। Explorer সম্ভাবনা মাপে না, সম্ভব কি না তা দেখায়। একটি খারাপ ক্রম থাকলেই ভুলটি আসল, শুধু কখন ঘটবে তা অজানা।
এই কৌশলের সীমা হলো সংখ্যার বিস্ফোরণ। দুজনের দশটি করে ধাপ হলে ক্রম ২০C১০ = ১,৮৪,৭৫৬; পাঁচজনের তিনটি করে ধাপ হলে ১৬,৮১,৬৮,০০০। তাই বাস্তব tool পুরো জগৎ চালায় না; বুদ্ধি করে বাছাই করে। একটি পরিচিত ধারণা হলো preemption-এর সংখ্যা সীমিত রাখা: “একজনকে মাঝপথে থামিয়ে অন্যকে চালানো” সর্বোচ্চ দুই-তিনবার। ওপরের উদাহরণে একটিমাত্র থামানোই যথেষ্ট ছিল। এই ধরনের পদ্ধতিকে বলে systematic concurrency testing; প্রশ্ন ৫-এ এর ইতিহাস আছে।
৪ · Barrier দিয়ে stress — সবাইকে একসাথে ছেড়ে দেওয়া
Explorer-এর জন্য কোডকে ধাপে ভাগ করতে হয়, যা সবসময় সম্ভব নয়। আসল thread-এর আসল কোডে দ্বিতীয় কৌশল stress test: অনেকবার, অনেক thread দিয়ে চালানো, আর প্রতিবার invariant যাচাই। কিন্তু সাধারণভাবে thread চালু করলে প্রথমটি শুরু হতে হতে শেষটি তখনো তৈরিই হয়নি; তারা আসলে একসাথে চলে না। সমাধান একটি barrier: সবাই একটি দরজার সামনে জমা হয়, আর নির্দিষ্ট সংখ্যক জমা হলে দরজা একসাথে খোলে। ঠিক যেমন দৌড় প্রতিযোগিতায় বাঁশি: সবাই দাগে দাঁড়ায়, বাঁশি বাজলে একসাথে দৌড়।
নিচের সবকিছু একটি সাধারণ Windows ডেস্কটপে সত্যিকারভাবে চালানো: Python 3.12.13, pytest 9.2.0 (MIT), pytest-asyncio 1.5.0 (Apache-2.0), httpx 0.28.1 (BSD-3-Clause). App হলো কোর্সের বাজারঘর-এর একটি নিজস্ব copy, শুধু 127.0.0.1-এ, test mode-এ, নিজের SQLite ফাইলে। এই tool-গুলো কোনো usage data পাঠায় না; সতর্কতা হিসেবে DO_NOT_TRACK=1 রাখা হয়েছিল। Path নিরপেক্ষ করা।
cd ~/bazarghar-qa/app # the course app, own copy
uv sync && uv add --dev pytest-asyncio
uv run pytest labtests -v -s -p no:cacheproviderপ্রথম test-এ server নেই: একটি সাধারণ Python class, স্টক ৩, আটটি thread প্রতিটি একবার কেনার চেষ্টা করে। threading.Barrier(8) আটজনকে একসাথে ছাড়ে। প্রতিটি রাউন্ড নতুন class দিয়ে, ২০০ রাউন্ড, আর invariant: “বিক্রি কখনো ৩-এর বেশি নয়।” তিনটি সংস্করণ: (১) সাধারণ কোড; (২) check আর act-এর মাঝে time.sleep(0), যা thread-কে বলে “চাইলে এখানে অন্যকে চালাও”, অর্থাৎ জানালাটি একটু বড় করা; (৩) একই কোড, কিন্তু check আর act একটি lock-এর ভেতরে।
class Stock:
def __init__(self, n, yield_point, lock):
self.n, self.sold = n, 0
self.yield_point, self.lock = yield_point, lock
def _buy(self):
if self.n >= 1: # check
if self.yield_point:
time.sleep(0) # let another thread run HERE
self.n -= 1 # act
self.sold += 1
def buy(self):
if self.lock is None:
return self._buy()
with self.lock: # check + act as one step
return self._buy()
def one_round(yield_point, lock):
stock = Stock(3, yield_point, lock)
gate = threading.Barrier(THREADS) # all 8 start together
def buyer():
gate.wait()
stock.buy()
ts = [threading.Thread(target=buyer) for _ in range(THREADS)]
for t in ts: t.start()
for t in ts: t.join()
return stock.soldTest function তিনটি সংস্করণে parametrize করা; প্রতিটি ২০০ রাউন্ড চালিয়ে বেশি-বিক্রির রাউন্ড গোনে। সত্যিকারের ফল (অংশ):
labtests/test_counter_threads.py::test_never_sell_more_than_stock[no-yield]
200 rounds: oversold in 0, max sold 3
PASSED
labtests/test_counter_threads.py::test_never_sell_more_than_stock[yield]
200 rounds: oversold in 164, max sold 8
FAILED
labtests/test_counter_threads.py::test_never_sell_more_than_stock[yield+lock]
200 rounds: oversold in 0, max sold 3
PASSED
…
E assert not [4, 4, 4, 4, 4, 4, ...]
তিনটি শিক্ষা। প্রথম: সাধারণ কোডে ২০০ রাউন্ডে একবারও ভুল দেখা গেল না, অথচ §৩ প্রমাণ করেছে ভুলটি সম্ভব। CPython-এর GIL (পাইথন কোর্সের পর্ব ৪৪) একবারে একটি thread-কে Python কোড চালাতে দেয়, আর এত ছোট function মাঝপথে প্রায় কখনো থামে না। এটিই heisenbug-এর চেহারা: “আমার মেশিনে তো ঠিক আছে।” দ্বিতীয়: একটি sleep(0) জানালা খুলে দিতেই ২০০-র ১৬৪ রাউন্ডে বেশি বিক্রি, কোনো রাউন্ডে ৮টিই (স্টক −৫)। আগের একটি run-এ সংখ্যাটি ছিল ১৪১; প্রতি run-এ আলাদা, কারণ ক্রম আলাদা। আসল কোডে এই “জানালা” আসে database query, network call বা file লেখা থেকে, যেগুলো thread-কে স্বাভাবিকভাবেই থামায়। তৃতীয়: lock-সহ সংস্করণ একই জানালায় ২০০-তে ০। ঠিক করার প্রমাণ হলো একই চাপে আগে-লাল test এখন সবুজ।
সবুজ stress test প্রমাণ নয়। “২০০ রাউন্ডে ০” শুধু বলে এই ২০০টি ক্রমে ভুল হয়নি। তাই stress test-এ (১) barrier দিয়ে শুরু একসাথে করুন, (২) সম্ভব হলে test-এর জন্য জানালা বড় করুন (sleep, ধীর fake), (৩) প্রথমে ইচ্ছা করে ভাঙা সংস্করণে চালিয়ে দেখুন test লাল হয় কি না। যে concurrency test কখনো লাল হতে দেখেননি, সে কিছু ধরে কি না, আপনি জানেন না। Python-এর free-threaded build (GIL ছাড়া) বা অন্য ভাষায় একই কোডে ভুল অনেক বেশি দেখা দিতে পারে।
৫ · বাজারঘরে শেষ ৩টি দুধ — HTTP-তে একসাথে চেকআউট
এবার আসল app. বাজারঘরের seed-এ গুঁড়া দুধের (product 11) স্টক মাত্র ৩। পাঁচজন ব্যবহারকারী (mitu, rafi, sumi, joy আর admin) প্রত্যেকে কার্টে ১টি দুধ রাখেন; কার্টে রাখার সময় স্টক ৩, তাই পাঁচজনেরই সফল। তারপর পাঁচজন একই মুহূর্তে POST /api/orders পাঠান। Requirement থেকে প্রত্যাশা: ঠিক ৩টি অর্ডার 201, ২টি 409 insufficient_stock, শেষে স্টক ০।
এখানে thread নয়, asyncio আর httpx-এর async client: একটি thread থেকেই পাঁচটি অনুরোধ একসাথে উড়ে যায়, আর server নিজের thread pool-এ সেগুলো একসাথে চালায়। asyncio.Barrier (Python 3.11 থেকে) একই দরজার কাজ করে। Test function-টি async def, তাই pytest-কে বলতে হয় এটি একটি event loop-এ চালাতে; সেই কাজ pytest-asyncio-র @pytest.mark.asyncio-এর।
async def one_round(c):
await c.post("/api/test/reset") # milk stock back to 3
heads = [await login(c, who) for who in BUYERS]
for h in heads: # 5 carts, 1 milk each
r = await c.post("/api/cart/items", json={"product_id": MILK, "qty": 1}, headers=h)
r.raise_for_status()
gate = asyncio.Barrier(len(heads))
async def checkout(h):
await gate.wait() # all 5 leave together
r = await c.post("/api/orders", json=ORDER, headers=h)
return r.status_code
codes = await asyncio.gather(*(checkout(h) for h in heads))
stock = (await c.get(f"/api/products/{MILK}")).json()["stock"]
return tuple(sorted(codes)), stock
@pytest.mark.asyncio
async def test_last_three_milk_packets_never_oversold():
async with httpx.AsyncClient(base_url=BASE, timeout=30) as c:
results = [await one_round(c) for _ in range(ROUNDS)]
for (codes, stock), n in Counter(results).items():
print(f"\n {n:2} rounds: status {codes} stock after {stock}")
for codes, stock in results:
assert codes == (201, 201, 201, 409, 409) and stock == 0লক্ষ করুন assert কী দাবি করে: শুধু “বিক্রি ≤ ৩” নয়, হেরে যাওয়া দুজন ঠিক 409 পাবেন, আর স্টক ঠিক ০। এই কড়াকড়ি একটু পরে কাজে লাগবে। কোর্সের app-এ (কোনো পরিবর্তন ছাড়া) সত্যিকারের ফল:
labtests/test_oversell.py::test_last_three_milk_packets_never_oversold
20 rounds: status (201, 201, 201, 409, 409) stock after 0
PASSED
২০ রাউন্ডের প্রতিটিতে একই ফল: বেশি বিক্রি হয়নি। সৎ উত্তর তাই: বাজারঘর এই চাপে নিরাপদ। কেন, তা কোড পড়লে বোঝা যায়: app প্রতিটি লেখার কাজ (কার্ট, অর্ডার, pay) একটি process-ব্যাপী lock-এর ভেতরে চালায়, তাই স্টক দেখা আর কমানো কখনো অন্য অর্ডারের সাথে মেশে না। নিচের stepper-এ একটি রাউন্ড:
| ঘটনা | |
| milk stock | |
| উত্তর |
- প্রস্তুতি। Test mode-এর reset seed ফেরায়, স্টক ৩। পাঁচজন login করে প্রত্যেকে কার্টে ১টি দুধ রাখেন; প্রত্যেকবার ১ ≤ ৩, তাই সবাই সফল। কার্ট যাচাই আর চেকআউট যাচাই আলাদা, তাই কার্টে ৫টি থাকা সম্ভব।
- দরজা। প্রতিটি coroutine
gate.wait()-এ থামে। চারজন অপেক্ষা করে; পঞ্চমজন পৌঁছালে barrier সবাইকে একসাথে ছাড়ে। - একসাথে উড়ছে। পাঁচটি অনুরোধ প্রায় একই মুহূর্তে server-এ পৌঁছায়। Server-এর thread pool সেগুলো আলাদা thread-এ নেয়: সত্যিকারের একসাথে চলা।
- প্রথম তিনজন। App-এর lock একবারে একজনকে ঢুকতে দেয়। প্রত্যেকে স্টক দেখে (৩, তারপর ২, তারপর ১), অর্ডার লেখে, স্টক কমায়, তারপর lock ছাড়ে। তিনটি
201. - শেষ দুজন। তাঁরা যখন ঢোকেন, স্টক ০; চেকআউটের যাচাই আবার হয় (TOCTOU এড়ানো), তাই
409 insufficient_stock. - যাচাই। Sorted status-এর tuple ঠিক প্রত্যাশামতো, স্টক ০। কোন দুজন হারবেন তা প্রতি রাউন্ডে বদলাতে পারে; তাই test নির্দিষ্ট ব্যবহারকারী নয়, ফলের গঠন যাচাই করে।
- ভাঙা copy. নিজের lab-এর copy-তে lock সরালে সবাই একসাথে স্টক ৩ দেখেন। কিন্তু database-এর
CHECK (stock >= 0)চতুর্থ স্টক-কমানো আটকায়; ফল দুটি500, বেশি বিক্রি নয়। Test লাল, কারণ assert409চেয়েছিল।
শেষ ধাপটি আরও খুলে বলা দরকার। Test-টি সত্যিই race ধরতে পারে কি না, তা জানতে নিজের lab-এর copy-তে services.py-এ একটি lab-only switch বসানো হলো, যা app-এর lock বাদ দেয় (কোর্সের মূল app অপরিবর্তিত)। একই test, একই ২০ রাউন্ড:
labtests/test_oversell.py::test_last_three_milk_packets_never_oversold
20 rounds: status (201, 201, 201, 500, 500) stock after 0
FAILED
E AssertionError: assert ((201, 201, 201, 500, 500) == (201, 201, 201, 409, 409)
# server log, 40 times (2 per round):
sqlite3.IntegrityError: CHECK constraint failed: stock >= 0
ফলটি শিক্ষণীয়, আর প্রত্যাশার চেয়ে আলাদা। Lock ছাড়া পাঁচজনই স্টক ৩ পড়ে check পার হয়েছিলেন, ঠিক §৩-এর ছবির মতো; প্রতিটি রাউন্ডে race ঘটেছে। কিন্তু স্টক কমানো লেখা আছে SET stock = stock - ? হিসেবে (পুরোনো মান থেকে হিসাব করে লেখা নয়), তাই database প্রতিবার সর্বশেষ মান থেকে কমায়, আর ০-এর নিচে নামার মুহূর্তে table-এর CHECK নিয়ম পুরো transaction ফিরিয়ে দেয়। Database-স্তরের এই দ্বিতীয় পাহারা বেশি বিক্রি ঠেকিয়েছে, কিন্তু ব্যবহারকারী পেয়েছেন একটি অব্যাখ্যাত 500, সুন্দর “স্টক নেই” বার্তার বদলে। Release-এর আগে এটিই ধরা পড়ার কথা: test যদি শুধু “বিক্রি ≤ ৩” দেখত, তাহলে সবুজ থাকত। Window বড় করার জন্য ৫০ ms-এর একটি lab-only দেরি যোগ করেও চালানো হয়েছিল; ফল হুবহু একই (২০টিতে ২০টি)। Barrier নিজেই যথেষ্ট ছিল, কারণ পাঁচটি অনুরোধ এত কাছাকাছি পৌঁছায় যে সবাই প্রথম লেখার আগেই পড়ে ফেলে।
Concurrency test-এ assert করুন তিন স্তরে: invariant (বিক্রি ≤ স্টক, স্টক ≥ ০), ব্যবহারকারীর অভিজ্ঞতা (হেরে যাওয়া অনুরোধ নির্দিষ্ট 4xx পায়, 500 নয়), আর data (অর্ডারের সংখ্যা আর স্টকের যোগফল মেলে)। Database-এর CHECK আর UNIQUE শেষ প্রতিরক্ষা; সেগুলো ভুলকে নিরাপদ করে, কিন্তু ঠিক করে না। Lost update-এর database-দিক (isolation, transaction) পর্ব ৩৩-এ আছে; এখানে তা আবার নয়।
৬ · একসাথে retry — idempotency চাপের মধ্যে
পর্ব ৩৭-এ একটি সত্যিকারের ভুল পেয়েছিলেন: wallet timeout-এর পরে HTML pay form আবার চাপলে দুটি charge হয়, কারণ form প্রতিটি পাতা দেখানোর সময় নতুন idempotency key বসায়। পর্ব ৩৪-এ দেখেছেন key-র আসল নিয়ম: “একটি পেমেন্টের চেষ্টার জন্য একটি key, যত retry-ই হোক।” এবার প্রশ্নটি concurrency-র: একই অর্ডারে পাঁচটি pay অনুরোধ একসাথে এলে কী হয়? এটি কল্পনা নয়; অধৈর্য ব্যবহারকারীর দ্রুত দুবার চাপ, mobile network-এ client library-র নিজে থেকে retry, বা load balancer-এর পুনরায় পাঠানো, সবই একই ঘটনা ঘটায়।
Test-এর সেটআপ: reset, তারপর fake gateway-কে timeout_once mode-এ রাখা (প্রথম charge হয়ে যায় কিন্তু app timeout দেখে; পরেরগুলো সফল), mitu-র একটি mobile-wallet অর্ডার, তারপর barrier দিয়ে পাঁচটি POST /api/orders/{id}/pay. দুটি সংস্করণ: পাঁচটিতেই একই key, আর প্রতিটিতে আলাদা key. Invariant: “একটি অর্ডারে ledger-এ ঠিক ১টি charge.”
@pytest.mark.asyncio
@pytest.mark.parametrize("keys", [["k-same"] * 5, [f"k-{i}" for i in range(5)]],
ids=["same-key", "new-key-each"])
async def test_five_parallel_pays_charge_once(keys):
async with httpx.AsyncClient(base_url=BASE, timeout=30) as c:
h, oid = await setup_order(c) # reset, timeout_once, order
gate = asyncio.Barrier(len(keys))
async def pay(key):
await gate.wait()
r = await c.post(f"/api/orders/{oid}/pay",
headers={**h, "Idempotency-Key": key})
return r.status_code, r.headers.get("Idempotent-Replayed", "-")
answers = await asyncio.gather(*(pay(k) for k in keys))
ledger = (await c.get("/api/test/wallet")).json()["charges"]
charges = [x for x in ledger if x["order_id"] == oid]
print(f"\n answers {sorted(answers)} charges for order {oid}: {len(charges)}")
assert len(charges) == 1সত্যিকারের ফল:
labtests/test_pay_concurrent.py::test_five_parallel_pays_charge_once[same-key]
answers [(200, '-'), (200, 'true'), (200, 'true'), (200, 'true'), (504, '-')] charges for order 8: 1
PASSED
labtests/test_pay_concurrent.py::test_five_parallel_pays_charge_once[new-key-each]
answers [(200, '-'), (409, '-'), (409, '-'), (409, '-'), (504, '-')] charges for order 8: 2
FAILED
E AssertionError: assert 2 == 1
========================= 2 failed, 4 passed in 5.36s =========================
(শেষ লাইনটি পুরো labtests run-এর: দুটি লাল হলো §৪-এর yield সংস্করণ আর এই new-key-each; দুটিই ইচ্ছাকৃত।) উত্তরগুলোর পেছনের ক্রম ধাপে ধাপে:
| কে ঢুকল | |
| যা ঘটে | |
| HTTP | |
| order | |
| charge |
- একসাথে পৌঁছানো। পাঁচটি অনুরোধ একই key K নিয়ে আসে। App-এর lock একবারে একজনকে ঢোকায়; কে প্রথম, তা প্রতিবার আলাদা হতে পারে।
- প্রথমজন: টাকা গেল, উত্তর গেল না। Key আগে ব্যবহার হয়নি, অর্ডার
placed. Gatewayref=K-এ charge লেখে, তারপর timeout. App504দেয়; সফল হয়নি বলে key-র উত্তর জমা হয় না। - দ্বিতীয়জন: gateway চিনে ফেলে। অর্ডার এখনো
placed, তাই আবার charge-এর চেষ্টা। কিন্তু gateway দেখেref=Kআগে থেকেই আছে, আর নতুন charge না করে আগেরটিই ফেরত দেয়। অর্ডারpaid, key-র উত্তর জমা,200. - বাকি তিনজন: replay. Key-র জমা উত্তর পাওয়া যায়, তাই কিছুই আবার চলে না; একই উত্তর, সাথে
Idempotent-Replayed: true. Ledger-এ ১টি charge: test সবুজ। - আলাদা key, প্রথমজন। এবার প্রতিটি অনুরোধের key আলাদা। প্রথমজন
k-a-তে charge করে, timeout,504. অর্ডারplaced. - দ্বিতীয়জন: নতুন ref, নতুন charge.
k-bgateway-র কাছে অচেনা, তাই সত্যিই দ্বিতীয়বার টাকা কাটে। অর্ডারpaid. Ledger-এ ২টি charge. - বাকিরা থামে, কিন্তু দেরিতে। অর্ডার
paid, তাই তিনটি409. State machine আরও charge ঠেকাল, কিন্তু দ্বিতীয়টি ইতিমধ্যে হয়ে গেছে। Test লাল: পর্ব ৩৭-এর দ্বিগুণ charge, এবার API-তে, একসাথে।
এখান থেকে tester-এর তিনটি সিদ্ধান্ত। প্রথমত, same-key সংস্করণটি regression test হিসেবে suite-এ থাকবে; ভবিষ্যতে কেউ “replay”-এর কোড বদলালে লাল হবে। দ্বিতীয়ত, new-key সংস্করণটি app-এর ভুল কি না, তা product-এর প্রশ্ন: README বলে key ছাড়া বা নতুন key-তে retry মানে নতুন চেষ্টা। কিন্তু একটি অর্ডারে timeout-এর পরে একটি charge ঝুলে থাকা অবস্থায় আরেকটি charge হতে দেওয়া ব্যবহারকারীর জন্য বিপজ্জনক; বাস্তব system-এ অনেক সময় অর্ডার-স্তরে আরেকটি পাহারা থাকে (“এই অর্ডারে অমীমাংসিত charge আছে কি?”)। তৃতীয়ত, এই ধরনের test-এ সবসময় পার্শ্ব-প্রতিক্রিয়া গুনুন (ledger-এর সারি, পাঠানো SMS, স্টকের পরিবর্তন), শুধু HTTP status নয়: same-key-তে 504 থাকা সত্ত্বেও টাকা ঠিক একবার কেটেছে, আর সেটিই আসল প্রশ্ন। Queue আর event-এর জগতে idempotency (একই বার্তা দুবার আসা) পর্ব ৭০ (Microservice আর event-driven system-এর testing)-এ আসবে।
৭ · Async কোডের test — event loop, timeout আর deadlock
Async কোডে (Python-এর async/await, JavaScript-এর Promise) একটি thread-এ একটি event loop অনেক coroutine পালা করে চালায়। একটি গুরুত্বপূর্ণ পার্থক্য: thread-কে operating system যেকোনো জায়গায় থামাতে পারে, কিন্তু coroutine থামে শুধু await-এ। ফলে async কোডের race অনেক বেশি পূর্বানুমেয়: দুটি await-এর মাঝের কোড অন্য coroutine-এর চোখে অবিভাজ্য। আর check আর act-এর মাঝে একটি await থাকলেই (database, wallet, অন্য service) জানালা খুলে যায়। নিচের কোডে পাঁচজন ক্রেতা, স্টক ৩, তিনটি সংস্করণ, প্রতিটি তিনবার:
import asyncio
async def buy(shop, name, pause, lock):
async def attempt():
if shop["stock"] >= 1: # check
if pause:
await asyncio.sleep(0) # e.g. await the wallet call
shop["stock"] -= 1 # act
shop["sold"].append(name)
if lock is None:
await attempt()
else:
async with lock: # check + act together
await attempt()
async def run(pause, use_lock):
shop = {"stock": 3, "sold": []}
lock = asyncio.Lock() if use_lock else None
await asyncio.gather(*(buy(shop, f"c{i}", pause, lock) for i in range(1, 6)))
return shop
for pause, use_lock in [(False, False), (True, False), (True, True)]:
for attempt in range(3): # same result every time?
shop = await run(pause, use_lock)
print(f"await={pause!s:5} lock={use_lock!s:5} try {attempt + 1}: "
f"sold {len(shop['sold'])}, stock {shop['stock']:2}")আসল আউটপুট:
await=False lock=False try 1: sold 3, stock 0
await=False lock=False try 2: sold 3, stock 0
await=False lock=False try 3: sold 3, stock 0
await=True lock=False try 1: sold 5, stock -2
await=True lock=False try 2: sold 5, stock -2
await=True lock=False try 3: sold 5, stock -2
await=True lock=True try 1: sold 3, stock 0
await=True lock=True try 2: sold 3, stock 0
await=True lock=True try 3: sold 3, stock 0
তিনটি জিনিস লক্ষ করুন। (১) মাঝে await না থাকলে কোনো race নেই: ৩টি বিক্রি, স্টক ০। (২) একটি await যোগ করতেই প্রতিবার ৫টি বিক্রি, স্টক −২: পাঁচজনই check পার হয়ে থামে, তারপর পাঁচজনই কমায়। (৩) তিনবারই হুবহু একই ফল। Thread-এর ২০০ রাউন্ডে ১৬৪ বা ১৪১-এর মতো এলোমেলো সংখ্যা নয়; একটি event loop আর এই সরল কোডে ক্রম পুরোপুরি নির্ধারিত (deterministic). এটি tester-এর জন্য সুখবর: async race-এর test একবারেই নির্ভরযোগ্যভাবে লাল হয়। asyncio.Lock দিয়ে check আর act একসাথে বাঁধলে ৩ আর ০। সাবধান: আসল network বা timer থাকলে ক্রম আবার সময়ের ওপর নির্ভর করতে পারে।
Async test চালানোর tool: pytest নিজে coroutine চালায় না। pytest-asyncio test-কে event loop-এ চালায় (@pytest.mark.asyncio, বা config-এ asyncio_mode = auto), আর loop-এর পরিসর (function, module, session) ঠিক করা যায়। এর আসল run-এ একটি সতর্কবার্তা এসেছিল যে async fixture-এর loop-এর পরিসর ঠিক করা নেই; config-এ asyncio_default_fixture_loop_scope = "function" লিখলে চলে যায়। বিকল্প হলো anyio-র নিজের pytest plugin (@pytest.mark.anyio, anyio MIT লাইসেন্স), যা একই test asyncio আর trio দুই backend-এ চালাতে পারে; বাজারঘরের সাথে anyio আগে থেকেই install হয়, তাই run-এর শিরোনামে plugins: anyio-4.16.0, asyncio-1.5.0 দেখা গেছে। দুটি একসাথে একই test-এ চাপাবেন না; একটি বেছে নিন।
সময়কে নিয়ন্ত্রণে আনা: async কোডে timeout, retry আর backoff প্রচুর। আসল ঘড়িতে test করলে suite ধীর আর flaky হয়। পর্ব ২৪-এর নিয়ন্ত্রিত ঘড়ির ধারণা এখানেও খাটে: সময়কে dependency বানিয়ে test-এ একটি fake clock দিন, বা পুরো event loop-এর সময় এগিয়ে দেয় এমন test loop ব্যবহার করুন (trio-র test সুবিধায় এমন ব্যবস্থা আছে)। নিয়ম একটিই: test-এ “৩ সেকেন্ড অপেক্ষা” মানে যেন সত্যিই ৩ সেকেন্ড বসে থাকা না হয়।
Deadlock ধরা: timeout হলো পাহারাদার। Deadlock-এ কোনো exception নেই, কোনো লাল লেখা নেই; program শুধু থেমে থাকে, আর CI-র job ঘণ্টার পর ঘণ্টা ঝুলে থাকে। তাই প্রতিটি concurrency test-এর চারপাশে একটি সময়সীমা দিন, যাতে আটকে থাকা একটি স্পষ্ট ব্যর্থতায় পরিণত হয়। নিচে বাজারঘর-ধাঁচের দুটি কাজ: চেকআউট আগে স্টকের সারি, পরে wallet-এর সারি ধরে; refund ধরে উল্টো ক্রমে। দ্বিতীয় run-এ দুজনেই একই ক্রমে (lock ordering):
import asyncio, time
async def job(name, first, second, log):
async with first:
await asyncio.sleep(0.01) # hold the first lock a moment
async with second:
log.append(name)
async def scenario(label, refund_order):
stock_row, wallet_row = asyncio.Lock(), asyncio.Lock()
log = []
checkout = job("checkout", stock_row, wallet_row, log)
first, second = refund_order(stock_row, wallet_row)
refund = job("refund", first, second, log)
t0 = time.monotonic()
try:
await asyncio.wait_for(asyncio.gather(checkout, refund), timeout=0.5)
result = f"done {log}"
except TimeoutError:
result = f"TIMEOUT, done {log} -> deadlock?"
print(f"{label:15} {time.monotonic() - t0:4.2f} s {result}")
await scenario("opposite order", lambda s, w: (w, s))
await scenario("same order", lambda s, w: (s, w))আসল আউটপুট:
opposite order 0.51 s TIMEOUT, done [] -> deadlock?
same order 0.02 s done ['checkout', 'refund']
উল্টো ক্রমে: চেকআউট স্টক ধরে, refund wallet ধরে, তারপর প্রত্যেকে অন্যের হাতেরটির অপেক্ষায়। কেউ শেষ করেনি (done []), আর ০.৫ সেকেন্ডের সময়সীমা না থাকলে program চিরকাল থেমে থাকত। একই ক্রমে দুজনেই কয়েক মিলিসেকেন্ডে শেষ। মনে রাখুন, timeout শুধু বলে “এত সময়ে শেষ হয়নি”; deadlock, অতিরিক্ত ধীরতা বা হারিয়ে যাওয়া বার্তা, তিনটিই একই রকম দেখায়। তাই timeout-এর বার্তায় কোন কাজ কী অবস্থায় আটকে ছিল, তা ছাপুন (এখানে log); আর সময়সীমা স্বাভাবিক সময়ের অনেক বেশি রাখুন, নইলে ব্যস্ত CI-তে test নিজেই flaky হবে। pytest-এ পুরো test-এর জন্য একই কাজ করে pytest-timeout plugin.
আরও শক্ত tool, যেখানে ভাষা সুযোগ দেয়: C/C++ আর Go-তে compiler-এর সাথে আসা race detector চালানোর সময় প্রতিটি memory-ব্যবহার আর lock-এর হিসাব রেখে data race ধরে: ThreadSanitizer (GCC আর Clang-এর -fsanitize=thread) আর Go-র go test -race, যা আমাদের জানামতে ভেতরে একই ধরনের runtime ব্যবহার করে। এরা শুধু সেই race দেখে যা run-এর সময় সত্যিই ঘটেছে, তাই ভালো stress test-এর সাথে জোড়া লাগে। Java-তে OpenJDK প্রকল্পের jcstress (Java Concurrency Stress) ছোট ছোট concurrent “পরীক্ষা” কোটি কোটি বার চালিয়ে প্রতিটি সম্ভাব্য ফল কতবার এলো তা গোনে, আর কোন ফল গ্রহণযোগ্য তা আগে থেকে লিখে রাখতে হয়। Rust-এর loom আর Microsoft Research-এর CHESS-এর মতো tool scheduler নিজের হাতে নিয়ে §৩-এর explorer-এর মতো ক্রম বাছাই করে চালায়। নাম জানাটুকুই যথেষ্ট; কোন tool আপনার ভাষায় আছে, তার official docs দেখে নিন।
আরও গভীরে: একসাথে চলা system-এর সঠিকতার একটি প্রচলিত মানদণ্ড linearizability (Maurice Herlihy আর Jeannette Wing, ১৯৯০): প্রতিটি কাজ যেন শুরু আর শেষের মাঝে কোনো এক মুহূর্তে একবারে ঘটেছে, আর সেই ক্রমের ফল একটি সাধারণ একক-thread মডেলের সাথে মেলে। আজকের অনেক test tool এই ধারণায় কাজ করে: একসাথে অনেক অনুরোধের ইতিহাস রেকর্ড করে, তারপর যাচাই করে কোনো বৈধ একক ক্রম দিয়ে সেই ইতিহাস ব্যাখ্যা করা যায় কি না। পর্ব ৫৮-এর stateful property test-কে একসাথে চালিয়ে এমন যাচাই করা যায়; কিছু property-based tool এই সুবিধা দেয় বলে জানা যায়। খরচ: সম্ভাব্য ক্রম জ্যামিতিক হারে বাড়ে, তাই ইতিহাস ছোট রাখতে হয়।
পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এমন প্রশ্ন আসতে পারে:
- Race condition কীভাবে test করবেন? — Barrier দিয়ে অনেক অনুরোধ একসাথে ছেড়ে বারবার চালানো, প্রতিবার invariant যাচাই; সম্ভব হলে জানালা বড় করা বা ক্রম নিয়ন্ত্রণ করা; প্রথমে ভাঙা সংস্করণে লাল হতে দেখা।
- Data race আর race condition-এর পার্থক্য? — প্রথমটি lock ছাড়া একই memory-তে একসাথে লেখা; দ্বিতীয়টি ফল ক্রমের ওপর নির্ভরশীল, যা প্রতিটি ধাপ নিরাপদ হলেও ঘটতে পারে।
- Deadlock-এর test কীভাবে? — প্রতিটি test-এ সময়সীমা; lock নেওয়ার একটি স্থির ক্রম; timeout-এ কে কী ধরে আছে তা লগে।
- দুবার “Pay” চাপলে দুবার টাকা কাটা ঠেকানো কীভাবে যাচাই করবেন? — একই Idempotency-Key-তে একসাথে কয়েকটি অনুরোধ, তারপর ledger-এ charge গোনা; key বদলালে কী হয় তাও দেখা।
- Async কোডে race কোথায় হয়? — শুধু
await-এ coroutine থামে; check আর act-এর মাঝে await থাকলেই।
৮ · AI-এর যুগে concurrency test
AI assistant-কে “এই endpoint-এর concurrency test লিখে দিন” বললে প্রায়ই যা আসে: একটি for loop, যা অনুরোধগুলো একটির পর একটি পাঠায় (আসলে কোনো concurrency নেই); বা thread চালু করে কিন্তু barrier ছাড়া, তাই বাস্তবে একসাথে চলে না; “race এড়াতে” time.sleep(1); assert শুধু “সব অনুরোধ 200”, যা বর্তমান কোড যা করে তাই নকল করে, requirement নয়; HTTP status দেখে, কিন্তু ledger বা স্টকের পার্শ্ব-প্রতিক্রিয়া গোনে না; পুরো database mock করে, ফলে আসল lock বা constraint কখনো চলে না; অস্তিত্বহীন pytest option বা fixture-এর নাম; আর একবার সবুজ দেখে, বা না চালিয়েই, “race নেই” দাবি।
AI-কে কোডের বদলে নিয়ম আর invariant দিন, আর test-এর গঠন স্পষ্ট করে চান:
AI-লেখা concurrency test হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১Therac-25 বিকিরণ-চিকিৎসা যন্ত্রের দুর্ঘটনায় একটি race condition-এর ভূমিকা ছিল বলে বর্ণিত। কী ঘটেছিল, আর কেন তা যন্ত্রের test-এ ধরা পড়েনি?
Therac-25 ছিল ক্যানসার রোগীদের বিকিরণ দেওয়ার একটি যন্ত্র। ১৯৮৫ থেকে ১৯৮৭ সালের মধ্যে যুক্তরাষ্ট্র আর কানাডার কয়েকটি হাসপাতালে ছয়টি দুর্ঘটনায় রোগীরা প্রচণ্ড মাত্রাতিরিক্ত বিকিরণ পান; কয়েকজন মারা যান। Nancy Leveson আর Clark Turner ১৯৯৩ সালে IEEE Computer পত্রিকায় এর বিস্তারিত তদন্ত প্রকাশ করেন, যা আজও software নিরাপত্তার পাঠ্য। তাঁদের বর্ণনা অনুযায়ী একাধিক ভুল ছিল; একটি হলো কাজের মধ্যে race. অভিজ্ঞ অপারেটর খুব দ্রুত চিকিৎসার তথ্য লিখে, তারপর কয়েক সেকেন্ডের মধ্যে (প্রায় আট সেকেন্ডের একটি জানালা, যখন যন্ত্রের চুম্বক সেট হচ্ছিল) একটি ঘর সংশোধন করলে, পর্দায় সংশোধন দেখা যেত, কিন্তু যন্ত্রের অন্য একটি কাজ পুরোনো মানেই এগিয়ে যেত। আরেকটি ভুলে একটি এক-byte counter উপচে শূন্য হয়ে নিরাপত্তা-যাচাই বাদ পড়ত।
কেন test-এ ধরা পড়েনি? প্রথমত, ভুলটি দেখা দিত শুধু একটি নির্দিষ্ট গতিতে: নতুন অপারেটর ধীরে লেখেন, তাই জানালায় পড়েন না; দক্ষ হয়ে উঠলে পড়েন। Test-এর লোকজন সাধারণত ধীরে, যত্ন নিয়ে লেখেন। দ্বিতীয়ত, আগের মডেলে hardware interlock ছিল, যা software-এর ভুল ঢেকে দিত; নতুন মডেলে সেই পাহারা সরিয়ে software-এর ওপর ভরসা করা হয়েছিল। §৫-এর বাজারঘরের সাথে তুলনা করুন: সেখানে database-এর CHECK ছিল সেই দ্বিতীয় পাহারা, যা race-কে বেশি বিক্রিতে পরিণত হতে দেয়নি। তৃতীয়ত, দুর্ঘটনার পরে প্রথম দিকে সমস্যা পুনরুৎপাদন করা যায়নি, কারণ কেউ সেই গতি আর ক্রম মেলাননি; পরে একজন হাসপাতালের পদার্থবিদ ধৈর্য ধরে অপারেটরের গতি নকল করে ভুলটি দেখান বলে বর্ণিত।
Tester-এর শিক্ষা স্পষ্ট: ব্যবহারকারীর গতি, বিশেষ করে দক্ষ ব্যবহারকারীর দ্রুত সংশোধন, একটি test-এর মাত্রা। আর “পুনরুৎপাদন করা যাচ্ছে না” মানে ভুল নেই নয়; মানে আপনি এখনো সঠিক ক্রম খুঁজে পাননি।
মূল উপলব্ধি: race-এর জানালা সময় দিয়ে তৈরি; test-এ সেই সময় আর ক্রম ইচ্ছা করে মেলাতে না পারলে সবচেয়ে মারাত্মক ভুলও “অদৃশ্য” থাকে।
প্র ০২২০০৩ সালের আগস্টে উত্তর আমেরিকার বড় blackout-এ একটি alarm software-এর race condition একটি কারণ হিসেবে উল্লেখ করা হয়। একটি নীরব ভুল কীভাবে বড় বিপর্যয়ের অংশ হলো, আর tester এখান থেকে কী শেখেন?
২০০৩ সালের ১৪ আগস্ট যুক্তরাষ্ট্রের উত্তর-পূর্ব আর কানাডার অন্টারিওর বিশাল এলাকায় বিদ্যুৎ চলে যায়; কয়েক কোটি মানুষ প্রভাবিত হন। যুক্তরাষ্ট্র-কানাডার যৌথ তদন্ত দলের প্রতিবেদন অনুযায়ী ঘটনার শুরু ওহাইওর একটি বিদ্যুৎ কোম্পানির এলাকায়: গাছের সংস্পর্শে কয়েকটি transmission line বন্ধ হয়। কিন্তু control room-এর অপারেটররা প্রায় এক ঘণ্টারও বেশি সময় জানতেন না, কারণ তাঁদের energy management system-এর alarm অংশটি নীরবে থেমে গিয়েছিল। পরে প্রকাশিত বিবরণে (প্রতিবেদন আর software নির্মাতার বিশ্লেষণের উদ্ধৃতি অনুযায়ী) এর কারণ হিসেবে alarm প্রক্রিয়ার একটি race condition-এর কথা আসে, যা একটি নির্দিষ্ট ঘটনাক্রমে দেখা দেয়, আর তারপর alarm-এর কাজ আটকে যায়, কোনো error ছাড়াই।
এখানে কয়েকটি বৈশিষ্ট্য এই পর্বের সাথে মেলে। ভুলটি বহু বছর চালু system-এ লুকিয়ে ছিল বলে বর্ণিত, অর্থাৎ সাধারণ অবস্থায় জানালাটি প্রায় কখনো খুলত না; খুলল ঠিক সেই দিন, যখন একসাথে অনেক ঘটনা এল। ব্যর্থতা ছিল নীরব: deadlock-এর মতো, কিছু ভাঙা দেখায় না, শুধু কাজ বন্ধ। আর ক্ষতি এসেছে ব্যর্থতার পরের অংশে: অপারেটররা পুরোনো, স্থির পর্দা দেখে ভেবেছেন সব ঠিক আছে। এটি TOCTOU-র মানবিক রূপ: তথ্য দেখা হলো এক সময়ে, ব্যবহার হলো অনেক পরে, মাঝে পৃথিবী বদলে গেছে।
Tester-এর জন্য তিনটি শিক্ষা। (১) “চাপের মধ্যে একসাথে অনেক ঘটনা” একটি আলাদা test পরিস্থিতি; স্বাভাবিক load-এ ঠিক থাকা যথেষ্ট নয় (পর্ব ৫০-এর stress). (২) আটকে যাওয়া ধরার জন্য heartbeat বা সময়সীমা দরকার, যাতে নীরব ব্যর্থতা জোরে বাজে; §৭-এর timeout ঠিক এই কাজ করে। (৩) Monitoring নিজেও একটি system, যার test লাগে: alarm থেমে গেলে কে জানাবে? এর বিস্তারিত পর্ব ৬৩ (Chaos আর resilience testing)-এ।
মূল উপলব্ধি: concurrency-র সবচেয়ে বিপজ্জনক ব্যর্থতা প্রায়ই crash নয়, নীরব থেমে থাকা; তাই test-এ “শেষ হলো কি না” সময়সীমা দিয়ে যাচাই করা “ফল ঠিক কি না”-র মতোই জরুরি।
প্র ০৩“Heisenbug” আর “Bohrbug” নামে software-এর ভুলকে ভাগ করার ধারণা কোথা থেকে এলো, আর এই ভাগ testing আর system নকশায় কী বদলায়?
Jim Gray, database আর transaction নিয়ে কাজের জন্য Turing পুরস্কারপ্রাপ্ত বিজ্ঞানী, ১৯৮৫ সালে একটি প্রভাবশালী প্রতিবেদন লেখেন: “Why Do Computers Stop and What Can Be Done About It?” সেখানে তিনি চালু system-এর ব্যর্থতার তথ্য দেখে software-এর ভুলকে দুই ভাগে ভাবার প্রস্তাব দেন। Bohrbug, পরমাণুর Bohr মডেলের মতো দৃঢ়: একই অবস্থায় প্রতিবার দেখা দেয়, তাই সহজে পুনরুৎপাদন আর ঠিক করা যায়। Heisenbug, Heisenberg-এর অনিশ্চয়তার নীতির নামে: দেখতে গেলে বা আবার চালালে চলে যায়। নামটি Gray-এর আগেও ছড়িয়েছিল বলে জানা যায়; Gray একে নির্ভরযোগ্যতার নকশার সাথে যুক্ত করেন।
তাঁর মূল পর্যবেক্ষণটি চমকপ্রদ: চালু system-এ যে ভুলগুলো থেকে যায়, তার বড় অংশ heisenbug, কারণ bohrbug-গুলো test-এ আগেই ধরা পড়ে। আর heisenbug-এর একটি “সুবিধা” আছে: কাজটি আবার চালালে প্রায়ই সফল হয়। এখান থেকে তিনি process pair আর transaction-ভিত্তিক নকশার যুক্তি দেন: ব্যর্থ হলে অবস্থা ফিরিয়ে আবার চেষ্টা। আজকের retry, idempotency key আর “crash করে আবার চালু” ধরনের নকশার পেছনে এই চিন্তার ছায়া আছে।
Testing-এ এই ভাগ দুটি জিনিস বদলায়। প্রথমত, একবার সবুজ বা একবার লাল দেখে সিদ্ধান্ত নেওয়া যায় না; §৪-এর মতো বহু রাউন্ড আর গণনা দরকার। দ্বিতীয়ত, retry একটি দুই দিকের তলোয়ার। Test suite-এ স্বয়ংক্রিয় retry (পর্ব ৪০) heisenbug-কে ঢেকে দেয়, আর product-এ retry ঠিক তখনই নিরাপদ, যখন কাজটি idempotent; §৬-এ দেখেছেন, key বদলে retry করলে দুবার টাকা কাটে। তাই heisenbug-এর মোকাবিলা হলো তাকে bohrbug বানানো: barrier, নিয়ন্ত্রিত ক্রম বা জানালা বড় করে একটি পুনরুৎপাদনযোগ্য test লেখা, যেমন §৫-এ প্রতি রাউন্ডে ২টি 500.
মূল উপলব্ধি: heisenbug-এর বিরুদ্ধে tester-এর কাজ হলো অনিশ্চয়তা সরিয়ে ভুলটিকে প্রতিবার দেখা যায় এমন রূপে আনা; retry দিয়ে ঢাকা নয়।
প্র ০৪বাস্তব open-source program-এর concurrency bug-এর একটি বড় গবেষণা বলে, বেশিরভাগ bug মাত্র দুটি thread দিয়েই দেখা দেয়। এই ফল কী, আর test নকশায় এর প্রভাব কী?
Shan Lu, Soyeon Park, Eunsoo Seo আর Yuanyuan Zhou ২০০৮ সালের ASPLOS সম্মেলনে “Learning from Mistakes” নামে একটি গবেষণা প্রকাশ করেন। তাঁরা চারটি বড় open-source program (একটি database server, একটি web server, একটি web browser আর একটি office suite) থেকে ১০৫টি সত্যিকারের concurrency bug বাছাই করে প্রতিটি খুঁটিয়ে দেখেন। আমাদের জানামতে তাঁদের প্রধান ফলগুলো এমন: deadlock নয় এমন bug-এর প্রায় সবই (প্রায় ৯৭%) দুটি ছাঁচে পড়ে: atomicity violation (যে ধাপগুলো একসাথে হওয়ার কথা, মাঝে অন্য কেউ ঢোকে) আর order violation (দুটি কাজের প্রত্যাশিত ক্রম মানা হয় না, যেমন initialise হওয়ার আগেই ব্যবহার)। আর মোট bug-এর প্রায় ৯৬% দেখা দেয় মাত্র দুটি thread-এর মধ্যে; বেশিরভাগ ক্ষেত্রেই অল্প কয়েকটি memory-ব্যবহারের একটি নির্দিষ্ট ক্রমই যথেষ্ট।
এই ফল test নকশাকে অনেক সহজ করে। §৩-এ দেখেছেন, সব interleaving চালানোর খরচ thread আর ধাপের সংখ্যার সাথে বিস্ফোরিত হয়। কিন্তু বেশিরভাগ bug যদি দুজনের মধ্যে আর কয়েকটি ধাপে ঘটে, তাহলে দুজনের ছোট পরিস্থিতি খুঁটিয়ে test করাই বড় লাভ দেয়: দুই ক্রেতা আর শেষ ১টি প্যাকেট, দুই admin আর একই স্টকের পাতা, দুই pay আর একই অর্ডার। পাঁচজন বা আটজনের stress test-এর মূল্য অন্য জায়গায়: তা জানালা খোলার সম্ভাবনা বাড়ায়, আর queue বা pool ভরে যাওয়ার মতো বড় আকারের সমস্যা দেখায়।
গবেষণাটি আরও দেখায় যে অনেক bug-এর প্রথম “সমাধান” ভুল বা অসম্পূর্ণ ছিল; lock যোগ করলেই সব হয় না, কারণ atomicity violation-এ প্রশ্নটি কোন ধাপগুলো একসাথে, শুধু lock আছে কি না নয়। এজন্যই ঠিক করার পরে একই নিয়ন্ত্রিত test আবার লাল থেকে সবুজ হতে দেখা জরুরি। মনে রাখুন, শতাংশগুলো চারটি নির্দিষ্ট program-এর বাছাই করা নমুনা থেকে; সব software-এর সার্বজনীন নিয়ম নয়।
মূল উপলব্ধি: অধিকাংশ concurrency bug ছোট: দুজন, কয়েকটি ধাপ, একটি ভুল ক্রম; তাই দুজনের পরিস্থিতি খুঁটিয়ে আর নিয়ন্ত্রিতভাবে test করুন, বড় stress দিয়ে তার পরিপূরক করুন।
প্র ০৫Microsoft Research-এর CHESS-এর মতো systematic concurrency testing tool এলোমেলো stress test থেকে কীভাবে আলাদা, আর “preemption bounding” কেন কাজ করে?
Stress test-এর মূল দুর্বলতা আপনি §৪-এ দেখেছেন: ক্রম ঠিক করে operating system, tester নয়। একই কোড ২০০ রাউন্ডে একবারও ভাঙেনি। ২০০০-এর দশকের মাঝামাঝি Madanlal Musuvathi আর Shaz Qadeer-এর নেতৃত্বে Microsoft Research-এ CHESS নামের একটি tool তৈরি হয় (প্রধান প্রবন্ধগুলো PLDI ২০০৭ আর OSDI ২০০৮-এ, আমাদের জানামতে)। এর ধারণা: thread-এর scheduler-কে tool নিজের হাতে নেয়, যাতে একবারে একটি thread চলে আর কোথায় থামবে তা tool ঠিক করে। তারপর পদ্ধতিগতভাবে একটির পর একটি ক্রম চালায়। কোনো ক্রমে ভুল হলে সেই ক্রম সংরক্ষিত থাকে, আর হুবহু আবার চালানো যায়: heisenbug তখন bohrbug.
সমস্যা সেই বিস্ফোরণ: সব ক্রম চালানো অসম্ভব। তাদের সমাধান ছিল preemption bounding: একটি thread-কে তার ইচ্ছার বিরুদ্ধে মাঝপথে থামানোর (preemption) সংখ্যা সীমিত রাখা, যেমন সর্বোচ্চ দুটি। যুক্তিটি প্র ০৪-এর গবেষণার সাথে মেলে: বেশিরভাগ বাস্তব bug দেখা দিতে খুব কম preemption লাগে। §৩-এর দুধের উদাহরণে একটিই যথেষ্ট ছিল: A-কে read আর act-এর মাঝে একবার থামানো। কম preemption-এর ক্রমের সংখ্যা thread-এর ধাপের তুলনায় অনেক ধীরে বাড়ে, তাই বড় program-এও সেগুলো চালানো যায়, আর প্রতিটি ধাপে পাওয়া ভুলের ক্রম ছোট আর পড়ার মতো থাকে।
একই চিন্তা নানা রূপে ছড়িয়েছে: Rust-এর loom ছোট concurrent কোডের ক্রম পদ্ধতিগতভাবে খোঁজে; distributed system-এ deterministic simulation test পুরো network আর ঘড়িকে একটি seed-বাঁধা simulator-এর ভেতরে চালায়, যাতে যেকোনো ব্যর্থ run হুবহু আবার চালানো যায়। Tester-এর ব্যবহারিক শিক্ষা: আপনার ভাষায় এমন tool না থাকলেও নকশাটি নিজের কোডে আনা যায়: ধাপগুলোকে ছোট function বা yield-বিন্দুতে ভাঙা (§৩), সময়কে fake clock বানানো, আর random-কে seed দিয়ে বাঁধা।
মূল উপলব্ধি: ক্রমকে নিয়ন্ত্রণে আনলে concurrency test এলোমেলো চেষ্টা থেকে পদ্ধতিগত অনুসন্ধান হয়; অল্প কয়েকটি থামানোর ক্রমেই বেশিরভাগ bug ধরা পড়ে।
অনুশীলন
খাতা-কলমে করুন; উত্তর খোলার আগে নিজের উত্তর লিখে রাখুন।
-
Test design, একবারের voucher: বাজারঘরে একটি নতুন নিয়ম আসছে: “একটি ২০০ টাকার উপহার-voucher code একবারই ব্যবহার করা যাবে। ব্যবহার হয়ে গেলে পরের চেষ্টায় 409
voucher_used.” Concurrency-র দিক থেকে অন্তত পাঁচটি test case লিখুন: পরিস্থিতি, কীভাবে একসাথে পাঠাবেন, আর প্রত্যাশিত ফল (HTTP আর data দুটোই)।- একই ব্যবহারকারী, দুটি tab: barrier দিয়ে একই code-এ দুটি চেকআউট। প্রত্যাশা: একটি 201 (ছাড় ২০০), একটি 409
voucher_used; ডেটাবেসে voucher-এর ব্যবহার ১টি। - দুজন ব্যবহারকারী, একই code: ৫ জন একসাথে। প্রত্যাশা: ঠিক ১টি 201, ৪টি 409; কোনো 500 নয়; ব্যবহার ১।
- Timeout-এর পরে retry, একই Idempotency-Key: প্রথম চেষ্টার উত্তর হারায়, তারপর একই key-তে আবার। প্রত্যাশা: একটি অর্ডার, ব্যবহার ১, দ্বিতীয় উত্তর replay.
- অর্ডার বাতিল আর নতুন ব্যবহার একসাথে: একজন voucher-সহ অর্ডার বাতিল করছেন (নিয়ম অনুযায়ী voucher ফেরত আসবে কি না, আগে product owner-কে জিজ্ঞেস), আরেকজন একই মুহূর্তে code দিচ্ছেন। প্রত্যাশা: নিয়ম যা-ই হোক, voucher কখনো একসাথে দুটি সক্রিয় অর্ডারে নেই।
- Deadlock-পাহারা: প্রতিটি test-এ সময়সীমা (যেমন ১০ সেকেন্ড); কয়েক রাউন্ড চালিয়ে প্রতিবার একই গঠনের ফল। আর একবার নিজের lab-এর copy-তে পাহারা সরিয়ে দেখা test লাল হয়।
লক্ষ করুন, প্রতিটিতে assert শুধু status নয়, voucher-এর ব্যবহার-সংখ্যাও। TOCTOU এড়াতে নিয়মটি চেকআউটের মুহূর্তে আবার যাচাই হওয়া উচিত, কার্টে code বসানোর সময় নয়।
- একই ব্যবহারকারী, দুটি tab: barrier দিয়ে একই code-এ দুটি চেকআউট। প্রত্যাশা: একটি 201 (ছাড় ২০০), একটি 409
-
ফল অনুমান করুন: একটি asyncio কোডে স্টক ২, চারজন ক্রেতা
asyncio.gatherদিয়ে একসাথে কেনেন। প্রতিটি কেনা:if stock >= 1:তারপরawait asyncio.sleep(0), তারপরstock -= 1; sold += 1. (ক) শেষে sold আর stock কত? (খ)await-এর লাইন মুছে দিলে? (গ) কোনো run-এ কি ফল বদলাবে?(ক) sold ৪, stock −২। চারজনই check পার হয়ে
await-এ থামেন (তখন স্টক ২), তারপর চারজনই কমান। (একটি scratch run-এ যাচাই করা:{'stock': -2, 'sold': 4}.)(খ) sold ২, stock ০।
awaitনা থাকলে একটি coroutine-এর check আর act-এর মাঝে অন্য কেউ চলে না; প্রথম দুজন কেনেন, পরের দুজন check-এ আটকান।(গ) না। একটি event loop আর এই সরল কোডে ক্রম নির্ধারিত; প্রতি run-এ হুবহু একই ফল। Thread-এর stress test-এর মতো রাউন্ডভেদে বদলায় না।
-
Test-এর ভুল খুঁজুন: একজন সহকর্মী লিখেছেন, আর বলছেন “race নেই, test সবুজ”:
অন্তত চারটি সমস্যা চিহ্নিত করুন।async def test_no_oversell(client, mitu): await client.post("/api/cart/items", json={"product_id": 11, "qty": 1}, headers=mitu) codes = [] for _ in range(5): r = await client.post("/api/orders", json=ORDER, headers=mitu) codes.append(r.status_code) time.sleep(0.2) assert codes.count(201) <= 3- কোনো concurrency নেই:
forloop-এ একটির পর একটিawait; প্রতিটি অনুরোধ আগেরটি শেষ হলে যায়। barrier আরgatherদরকার। - একই ব্যবহারকারী: একটি কার্ট; প্রথম অর্ডারের পরে কার্ট খালি, বাকি চারটি
400 cart_empty. Race-এর প্রশ্নই ওঠে না। পাঁচজন আলাদা ব্যবহারকারী আর আলাদা কার্ট দরকার। time.sleepasync test-এ: এটি পুরো event loop থামায়, আর অনুরোধগুলোকে আরও দূরে সরায়। Concurrency test-এ sleep দিয়ে সময় মেলানো উল্টো কাজ।- দুর্বল assert: শুধু “201 ≤ ৩”; হেরে যাওয়াদের status (409, 500 নয়) আর শেষে স্টক দেখে না। এই test সবসময় সবুজ, এমনকি app ভাঙা হলেও।
- একবারের run আর কোনো reset নেই: রাউন্ড, reset আর সময়সীমা নেই; আর কখনো ভাঙা সংস্করণে লাল হতে দেখা হয়নি।
- কোনো concurrency নেই:
-
হিসাব আর সিদ্ধান্ত: (ক) দুটি thread-এর প্রতিটির ৩টি ধাপ হলে কতগুলো interleaving? (খ) তিনটি thread, প্রতিটির ২টি ধাপ? (গ) দুটি thread, প্রতিটির ১০টি ধাপ? (ঘ) একটি bug report বলছে: “মাঝে মাঝে স্টক ঋণাত্মক হয়, পুনরুৎপাদন হয় না।” Report-টি কাজের করতে কী কী তথ্য যোগ করবেন?
(ক) ৬টি জায়গার ৩টি বাছাই: ৬C৩ = ২০. (খ) ৬! ÷ (২! × ২! × ২!) = ৭২০ ÷ ৮ = ৯০. (গ) ২০C১০ = ১,৮৪,৭৫৬. (তিনটিই scratch script-এ গোনা।) ধাপ সামান্য বাড়লেই সংখ্যা বিস্ফোরিত হয়; তাই বাস্তব tool সব নয়, অল্প preemption-এর ক্রম বাছাই করে।
(ঘ) কোন endpoint আর কোন পণ্য; কতজন একসাথে (load-এর মাত্রা, sale-এর সময়); ঘটনার সময় আর লগের অংশ (একই মিলিসেকেন্ডের অনুরোধ); কোন build আর কোন database; স্টকের আগের-পরের মান আর অর্ডারের তালিকা (কতগুলো বেশি বিক্রি); আর একটি পুনরুৎপাদনের চেষ্টা: barrier-ভিত্তিক script, কত রাউন্ডে কতবার ঘটল। “পুনরুৎপাদন হয় না” লেখার বদলে “৫টি একসাথে চেকআউটে ২০ রাউন্ডে ৩ বার” অনেক বেশি কাজের (পর্ব ১৮-এর intermittent defect-এর রিপোর্ট)।
নিজেকে যাচাই করুন
উত্তর বাছুন; সাথে সাথে ব্যাখ্যা দেখাবে।
ক্রমএকসাথে চেকআউটের একটি concurrency test-এর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Requirement থেকে invariant আর হেরে যাওয়াদের প্রত্যাশিত status লেখা
- প্রতি রাউন্ডে data reset করে আলাদা ব্যবহারকারী আর কার্ট তৈরি করা
- Barrier দিয়ে সব অনুরোধ একসাথে ছাড়া, সময়সীমা সহ
- Status, স্টক আর ledger-এর মতো পার্শ্ব-প্রতিক্রিয়া assert করা
- কয়েক রাউন্ড চালিয়ে প্রতিটি ফলের গঠন গোনা
- ইচ্ছা করে পাহারা সরানো সংস্করণে test লাল হয় কি না দেখা
দুজন ক্রেতা শেষ ১টি প্যাকেট কিনতে চান। প্রত্যেকের ধাপ: স্টক পড়া, ≥ ১ কি না যাচাই, তারপর স্টক কমানো। দুজনের ধাপ যেকোনোভাবে মিশতে পারলে কতগুলো ক্রমে প্যাকেটটি দুজনের কাছে বিক্রি হয়?
- ২০টির ২টি
- ২০টির ১০টি
- ২০টির ১৮টি
- ২০টির ২০টি
একটি API-তে প্রতিটি SQL statement নিজে নিরাপদ, কিন্তু “স্টক পড়া” আর “অর্ডার লেখা” আলাদা ধাপ, আর মাঝে lock নেই। দুই অনুরোধ একসাথে এলে শেষ ১টি জিনিস দুজনের কাছে বিক্রি হতে পারে। এটি কোন ধরনের ভুল?
- Deadlock
- Check-then-act race condition
- Livelock
- Data race, কারণ দুটি statement একই memory লেখে
একটি concurrency test আটটি thread চালু করে, কিন্তু কোনো barrier নেই। ২০০ রাউন্ডে কখনো লাল হয়নি। এর সবচেয়ে সম্ভাব্য ব্যাখ্যা কোনটি?
- কোডে race নেই, প্রমাণিত
- আটটি thread যথেষ্ট নয়, ৮০টি লাগবে
- pytest thread-এর ব্যর্থতা দেখায় না
- Thread-গুলো বাস্তবে একসাথে চলেনি, তাই race-এর জানালা খোলেনি
Wallet gateway-র timeout-এর পরে একই অর্ডারে পাঁচটি pay অনুরোধ একসাথে আসে, সবগুলোতে একই Idempotency-Key. Server key-র উত্তর জমা রাখে, আর gateway একই reference-এ দ্বিতীয়বার charge করে না। Test-এ কোন assert সবচেয়ে গুরুত্বপূর্ণ?
- Ledger-এ ওই অর্ডারের ঠিক ১টি charge আছে
- পাঁচটি উত্তরই 200
- প্রথম পাঠানো অনুরোধটিই 200 পায়
- পাঁচটি উত্তর ১ সেকেন্ডের মধ্যে আসে
Python-এর asyncio কোডে একটি coroutine স্টক যাচাই করে, তারপর await wallet.charge(), তারপর স্টক কমায়। Race-এর জানালা কোথায়?
- যেকোনো দুটি লাইনের মাঝে, thread-এর মতো
- কোথাও নেই, কারণ asyncio একটি thread-এ চলে
- যাচাই আর কমানোর মাঝের
await-এ - শুধু স্টক কমানোর লাইনের ভেতরে
একটি AI assistant চেকআউটের concurrency test লিখে দিল: পাঁচটি অনুরোধ asyncio.gather-এ, তারপর assert codes.count(201) <= 3. App-এর lock সরানো একটি copy-তে test চালালে ফল এলো তিনটি 201 আর দুটি 500, test সবুজ। মূল সমস্যা কী?
- gather অনুরোধ একসাথে পাঠায় না
- Assert দুর্বল: হেরে যাওয়াদের status (409, 500 নয়) আর স্টক যাচাই করে না
- 500 গোনা উচিত নয়, কারণ তা server-এর সমস্যা
- Database-এর CHECK constraint থাকা উচিত নয়
একটি integration test মাঝে মাঝে CI-তে ঘণ্টার পর ঘণ্টা ঝুলে থাকে, কোনো error ছাড়াই। দুটি কাজ দুটি lock উল্টো ক্রমে নেয়। Test-এ প্রথম কোন পরিবর্তন সবচেয়ে দরকারি?
- Test-এ সময়সীমা দেওয়া, আর timeout-এ কোন কাজ কোন lock ধরে আছে তা ছাপানো
- ব্যর্থ হলে test স্বয়ংক্রিয়ভাবে তিনবার retry করা
- দুটি কাজের মাঝে sleep বসানো
- Test-টি quarantine-এ পাঠিয়ে ভুলে যাওয়া
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- Concurrency-র ভুল নির্ভর করে interleaving-এর ওপর; একই test কখনো সবুজ, কখনো লাল। কৌশল: ক্রমকে ভাগ্যের বদলে নিজের হাতে নেওয়া।
- Check-then-act (আর তার নিরাপত্তা-রূপ TOCTOU) সবচেয়ে চেনা ভুল: দুজন ক্রেতা, শেষ ১টি প্যাকেট, ২০টি ক্রমের ১৮টিতে বেশি বিক্রি। দেখা আর করা একসাথে বাঁধুন।
- Stress test-এ barrier, অনেক রাউন্ড, বড় জানালা, আর আগে ভাঙা সংস্করণে লাল হতে দেখা; সবুজ মানে প্রমাণ নয়। Deadlock ধরতে প্রতিটি test-এ সময়সীমা।
- বাজারঘরে ৫টি একসাথে চেকআউট: lock-সহ কোনো বেশি বিক্রি নেই; lock সরানো copy-তেও CHECK ঠেকাল, কিন্তু 500 এলো। Invariant, হেরে যাওয়াদের status আর data, তিন স্তরে assert করুন।
- একসাথে retry-তে একই Idempotency-Key = ১টি charge; প্রতিবার নতুন key = ২টি। Async কোডে race শুধু
await-এ, আর একটি event loop-এ তা প্রতিবার একইভাবে ঘটে।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ৬৩ · Chaos আর resilience testing — ইচ্ছাকৃত গোলমালে system যাচাইপরবর্তী পর্বইচ্ছে করে বিপর্যয় ঘটিয়ে দেখা, system কতটা টিকে থাকে।
- সফটওয়্যার টেস্টিং ও QA · কোর্স হোম৮২টি পর্ব১৪টি মডিউলের পুরো রোডম্যাপ।
- পর্ব ৪০ · Flaky testআগের ধাপঅপেক্ষা, ক্রম আর concurrency থেকে আসা অনির্ধারিত test: মাপা, খোঁজা, quarantine.
- অপারেটিং সিস্টেম · পর্ব ২২গভীরে যানRace condition আর critical section-এর ভেতরের যন্ত্র।
- পাইথন প্রোগ্রামিং · পর্ব ৪৫পাশের ট্র্যাকasyncio, event loop আর await-এর ভিত্তি।