std - condition_variable: Foundations — Hinglish deep dive

5.2.25 · D1 · Coding › C++ Programming › std - condition_variable

Parent note padhne se pehle, tumhe dekhna hoga ki ek thread kya hota hai, "shared memory" kaisi dikhti hai, kyun do threads ek saath ek box ko touch karna dangerous hai, aur ek lock physically kya karta hai. Yeh page woh saari pictures bilkul scratch se banata hai.

1. Ek thread — apne haathon wala ek worker

Ek kitchen ki picture karo. Ek cook = ek thread. Do cook = do threads parallel mein kaam kar rahe hain. Woh ek hi kitchen share karte hain (same memory), lekin har kisi ke apne haath hain aur apni recipe mein apni jagah hai.

Yeh topic kyun zaroori hai: condition_variable tab hi samajh mein aata hai jab ek worker ko doosre worker ka intezaar karna ho. Koi doosra thread nahi, koi wait nahi, koi doorbell nahi.

2. Shared memory — woh ek box jise dono workers use karte hain

Figure s01 ko dobara dekho: beech mein laal box ek variable hai jise dono cook touch kar sakte hain. Jab cook A likhta hai aur cook B padhta hai, woh us box ke zariye baat kar rahe hain — yahi akela tarika hai jisse threads communicate karte hain.

Yeh topic kyun zaroori hai: woh "condition" jiska ek thread intezaar karta hai woh hamesha shared state ke baare mein koi fact hoti hai ("kya queue non-empty hai?"). Koi shared box nahi, toh kisi cheez ka intezaar karne ke liye kuch nahi hai.

Maano shared box mein number 5 hai, aur dono cook "ise padho, 1 jodo, wapas likho" run karte hain. Tumhe 7 expect hoga. Lekin timeline dekho:

Dono ne 5 padh liya koi likhne se pehle, dono ne 6 compute kiya, dono ne 6 likh diya. Ek +1 gum ho gaya. Bug kabhi kabhi hi aata hai, depend karta hai kaun tez tha — woh unpredictability hi "race" hai.

Yeh topic kyun zaroori hai: wait aur notify ko mutex ke saath isliye entangle kiya gaya hai taaki shared condition pe races rokhe ja sakein. Tum API tab tak nahi samajh sakte jab tak yeh danger feel na karo.

4. Mutex — box ke liye ek akela key

Ek bathroom ki picture karo jisme hook pe ek key hai. Tum key uthao, andar jaao, darwaza band karo. Baaki sab jo andar jaana chahein bahar khade rahenge jab tak tum bahar nahi aate aur key wapas nahi lagate.

Kyunki sirf key-holder hi andar ja sakta hai, ek waqt mein sirf ek thread box modify karta hai — figure s02 ki gum-ho-gayi-+1 wali race impossible ho jaati hai.

Yeh topic kyun zaroori hai: cv.wait ek locked mutex leta hai, us par kaam karta hai, aur use wapas deta hai. Mutex har condition-variable pattern ka aadha hissa hai.

5. RAII locks — `lock_guard` aur `unique_lock`

Key ko haath se pakadna error-prone hai: agar tum ise wapas laganaa bhool gaye (ek early return, ek exception), toh baaki sab hamesha ke liye intezaar karte rahenge — ek Deadlock. C++ ise RAII se fix karta hai: ek chhota object key ko tab pakadta hai jab woh banaya jaata hai aur ise automatically wapas laga deta hai jab woh scope se bahar jaata hai (closing }).

Yeh topic kyun zaroori hai: parent note producer ke liye lock_guard use karta hai (lock, push, auto-unlock) aur consumer ke liye unique_lock (kyunki woh wait call karta hai). Farq samajhna matlab hai kyun woh do choices alag hain yeh samajhna.

6. `#include`, `::`, aur `<>` — notation khud padhna

Parent note ki har line pe pure C++ syntax ke teen pieces aate hain. Aao har symbol earn karein.

Yeh topic kyun zaroori hai: parent page par har symbol — std::condition_variable, std::unique_lock<std::mutex>, std::queue<int> — exactly inhi teen notations se bana hai. Ab inमें से koi bhi mysterious nahi hai.

7. Predicate `P()` — box ke baare mein ek haan/naa ka sawaal

[]{ ... } C++ ka tarika hai ek throwaway function inline likhne ka. []{ return ready; } padhte hain "sawaal: kya ready abhi true hai?"

Yeh topic kyun zaroori hai: predicate woh "koi fact true ho jaata hai" hai jo core idea mein hai. Yeh "ek thread wait kar raha hai" aur "kiske liye" ke beech ka bridge hai.

8. Spurious wakeup — kyun hum loop karte hain, `if` nahi

Kyunki ek wakeup fake ho sakta hai, thread ko predicate dobara check karna hota hai har baar jab woh jaagta hai — exactly isliye upar wali equivalence ek while loop hai, single if nahi. Jaago, poochho "kya yeh sach mein true hai?", aur agar nahi toh wapas so jaao.

Yeh topic kyun zaroori hai: yahi akela fact wajah hai ki cv.wait(lk, pred) взагалі exist karta hai instead of ek simple "sleep until poked."

Prerequisite map

Upar se neeche padho: threads sharing ko possible banate hain, sharing races create karta hai, mutex races ko kabu mein karta hai, RAII locks mutex ko safely use karte hain, predicate batata hai kiska intezaar karna hai, spurious wakeups loop ko force karte hain — aur sab kuch std::condition_variable pe aa kar milta hai.

Equipment checklist

A thread is

execution ki ek line — ek single worker jo ek recipe step by step follow karta hai.

Shared state is

ek variable jo ek se zyada thread read ya write kar sake; threads ke beech communication ka akela tarika.

A race condition is

jab final result overlapping accesses ki unpredictable timing pe depend kare.

A mutex is

ek key wala lock; sirf key-holder shared state touch kar sakta hai, one-at-a-time access force karta hai.

std::lock_guard vs std::unique_lock

dono scope khatam hone par auto-unlock karte hain, lekin sirf unique_lock mid-scope unlock aur re-lock kar sakta hai — jo cv.wait ko chahiye.

std:: aur :: ka matlab

std standard-library namespace (drawer) hai; :: matlab hai "us drawer mein jaake yeh naam lo."

std::queue<int> mein <int> ka matlab

blank fill karna — ek queue jo int values rakhti hai.

A predicate is

ek function jo true/false return kare, yahaan lambda []{ return ...; } ke roop mein likha, woh condition batata hai jiska intezaar karna hai.

A spurious wakeup is

OS ka bina kisi notification ke sote thread ko jagana, isliye hum predicate ko loop mein dobara check karte hain.

cv.wait(lock, P) is equivalent to

while(!P()) cv.wait(lock); — jab tak jawaab "naa" hai tab tak sota raho.