👥 धडा 09 — Processes आणि jobs: इमारतीत कोण आहे

📍 तुम्ही इथे आहात: 12 पैकी धडा 09 · पुढे: lesson-10-scheduling

📦 या ब्रँचमध्ये काय आहे

धडे 01–09. Processes, signals, background jobs, वाट पाहणे आणि parallelism — आणि container च्या PID 1 ने करायलाच हव्यात अशा दोन गोष्टी.

bin/smoke_test.sh — L09: background मधला एक job आणि wait

🧒 5 वर्षांच्या मुलाला समजावल्यासारखे

प्रत्येक चालू program म्हणजे इमारतीतली एक व्यक्ती, जिच्याकडे badge क्रमांक (PID) आणि एक boss (parent) असतो. ps म्हणजे पाहुण्यांची वही. एखाद्याला बाहेर जायला सांगायचे असेल तर तुम्ही ध्वनिक्षेपक वापरता — एक signal: TERM म्हणजे "कृपया काम आवरा", KILL म्हणजे "बाहेर, आत्ताच", INT म्हणजे Ctrl-C, HUP म्हणजे "तुमच्या नोंदी पुन्हा वाचा". cmd & एखाद्याला background मध्ये कामाला पाठवतो; wait ते परत येईपर्यंत थांबतो; nohup मुळे तुम्ही घरी गेल्यावरही ते काम करत राहतात.

🗺️ आकृती

flowchart TD
  P1["PID 1 — init / the entrypoint"] --> B["bash (your shell)"]
  B --> J1["backup.sh &  (job 1)"] --> T["tar"]
  B --> J2["sleep 30 &  (job 2)"]
  B -.->|"kill -TERM"| J2

❓ काय

ps aux, pgrep -f name, top/htop, pstree. $$ या shell चा PID, $! शेवटचा background PID.
Signals: kill -TERM pid (15, पकडता येतो — साफसफाई करा), kill -KILL pid (9, पकडता येत नाही), -INT (2, Ctrl-C), -HUP (1, reload). trap पकडता येणारे signals पकडतो (धडा 08).
cmd & background · jobs · fg / bg · wait (सगळे) / wait $pid · nohup cmd & किंवा setsid logout नंतरही टिकतात · timeout 30 cmd.
Parallel: xargs -P 4 -n 1 cmd · parallel · & + wait.
Zombies (संपलेले, पण कोणी wait केले नाही) आणि orphans (parent मेला): PID 1 ने त्यांना गोळा करायलाच हवे — containers मध्ये tini. exec cmd shell ची जागा घेतो म्हणून signals खऱ्या program पर्यंत पोहोचतात.

🤔 का

Deploys जुने processes थांबवतात आणि नवे सुरू करतात; timeouts भरकटलेले processes मारतात; CI steps parallel चालवते; PID 1 ने TERM कडे दुर्लक्ष केले तर containers वाईट पद्धतीने मरतात. हे सगळे signal आणि job चेच प्रश्न आहेत.

🔧 कसे (या repo मध्ये)

smoke test मधला L09: (sleep 0.2; echo "the bell rang") & wait. backup.sh आपले lock trap मध्ये सोडते, म्हणून run च्या मधेच TERM आला तरी directory स्वच्छ राहते.

🧪 करून पाहा

sleep 300 & echo "pid $!"; jobs; kill -TERM %1; wait %1 2>/dev/null; echo "gone"
(trap 'echo "TERM received, cleaning up"; exit 0' TERM; sleep 60) & p=$!; sleep 0.3; kill -TERM $p; wait $p
for f in bin/*.sh; do (bash -n "$f" && echo "$f ok") & done; wait               # syntax-check in parallel
printf '%s\n' 1 2 3 4 | xargs -P 4 -I{} sh -c 'sleep 0.{}; echo job {}'
timeout 1 sleep 5; echo "timeout exit: $?"                                       # 124
ps -o pid,ppid,comm -p $$

✅ तपासा — तुम्हाला काय दिसायला हवे

एक PID, यादीत एक job, gone; trap केलेला process TERM received छापतो; तीन ok ओळी; जवळजवळ यादृच्छिक क्रमाने चार job N ओळी; timeout exit: 124; तुमचा shell आणि त्याचा parent.

🏁 तुम्ही आत्ताच काय सिद्ध केले

तुम्ही processes सुरू करू शकता, त्यांच्यावर लक्ष ठेवू शकता, त्यांना signal पाठवू शकता आणि त्यांची वाट पाहू शकता, काम parallel चालवू शकता, आणि KILL आधी TERM हा नम्र (आणि योग्य) क्रम का आहे हे तुम्हाला माहीत आहे.

⚠️ नेहमीच्या चुका

आधीच kill -9. process ला साफसफाईची संधीच मिळत नाही — locks आणि temp files तशाच राहतात.
exec शिवाय shell entrypoint: Docker चा TERM shell ला लागतो, app ला तो कधीच ऐकू येत नाही, 10 s नंतर KILL.
script च्या शेवटी wait विसरणे: children अजून चालू असतानाच ती exit होते.

🏭 प्रत्यक्ष वापरात हे का महत्त्वाचे: graceful shutdown, zero-downtime restarts, Kubernetes मधला 10 seconds चा grace period — सगळे म्हणजे "process TERM हाताळतो का?". Docker शाळेतला entrypoint चा धडा हाच आहे.

⏭️ पुढे

धडा 10 — scheduling आणि automation: घंटा, आणि एकाच वेळी कधीच दोनदा न चालणारा backup.

👥 Lesson 09 — Processes & jobs: who is in the building

📍 You are here: Lesson 09 of 12 · Next: lesson-10-scheduling

📦 What's in this branch

Lessons 01–09. Processes, signals, background jobs, waiting and parallelism — and the two things a container's PID 1 must do.

bin/smoke_test.sh — L09: a job in the background and wait

🧒 Explain like I'm 5

Every running program is a person in the building with a badge number (PID) and a boss (the parent). ps is the visitors' book. To ask someone to leave you use the tannoy — a signal: TERM means "please finish up", KILL means "out, now", INT is Ctrl-C, HUP is "reload your notes". cmd & sends someone off to work in the background; wait waits for them to come back; nohup lets them keep working after you go home.

🗺️ Diagram

flowchart TD
  P1["PID 1 — init / the entrypoint"] --> B["bash (your shell)"]
  B --> J1["backup.sh &  (job 1)"] --> T["tar"]
  B --> J2["sleep 30 &  (job 2)"]
  B -.->|"kill -TERM"| J2

❓ What

ps aux, pgrep -f name, top/htop, pstree. $$ this shell's PID, $! the last background PID.
Signals: kill -TERM pid (15, catchable — clean up), kill -KILL pid (9, not catchable), -INT (2, Ctrl-C), -HUP (1, reload). trap catches the catchable ones (lesson 08).
cmd & background · jobs · fg / bg · wait (all) / wait $pid · nohup cmd & or setsid survives logout · timeout 30 cmd.
Parallel: xargs -P 4 -n 1 cmd · parallel · & + wait.
Zombies (finished, not waited for) and orphans (parent died): PID 1 must reap them — tini in containers. exec cmd replaces the shell so signals reach the real program.

🤔 Why

Deploys stop old processes and start new ones; timeouts kill runaways; CI runs steps in parallel; containers die badly when PID 1 ignores TERM. All signal and job questions.

🔧 How (in this repo)

The smoke test's L09: (sleep 0.2; echo "the bell rang") & wait. backup.sh releases its lock in a trap so a TERM mid-run still leaves the directory clean.

🧪 Try it

sleep 300 & echo "pid $!"; jobs; kill -TERM %1; wait %1 2>/dev/null; echo "gone"
(trap 'echo "TERM received, cleaning up"; exit 0' TERM; sleep 60) & p=$!; sleep 0.3; kill -TERM $p; wait $p
for f in bin/*.sh; do (bash -n "$f" && echo "$f ok") & done; wait               # syntax-check in parallel
printf '%s\n' 1 2 3 4 | xargs -P 4 -I{} sh -c 'sleep 0.{}; echo job {}'
timeout 1 sleep 5; echo "timeout exit: $?"                                       # 124
ps -o pid,ppid,comm -p $$

✅ Verify — what you should see

A PID, one job listed, gone; the trapped process prints TERM received; three ok lines; four job N lines in near-random order; timeout exit: 124; your shell with its parent.

🏁 What you just proved

You can start, watch, signal and wait for processes, run work in parallel, and you know why TERM before KILL is the polite (and correct) order.

⚠️ Common mistakes

kill -9 first. The process gets no chance to clean up — locks and temp files stay.
A shell entrypoint without exec: Docker's TERM hits the shell, the app never hears it, 10 s later KILL.
Forgetting wait at the end of a script: it exits while children still run.

🏭 Why this matters in production: graceful shutdown, zero-downtime restarts, the 10-second grace period in Kubernetes — all "does the process handle TERM?". The Docker school's entrypoint lesson is this one.

⏭️ Next

Lesson 10 — scheduling & automation: the bell, and the backup that never runs twice at once.

← Previouserrors safety Next →scheduling

This page is the lesson's README from the lesson-09-processes-jobs branch, shown here so the whole School stays on one site. Code files open on GitHub at the same branch.