Theory
ચાલી રહેલા programs
જ્યારે કોઈ program ખરેખર server પર ચાલતો હોય ત્યારે એને process કહે છે. તમારો shell એક process છે; તમે હમણાં જ ચલાવેલો command એક process છે; background માં ગણગણતો web server પણ એક process છે. Kernel દરેકને એક અનન્ય Process ID (PID) આપે છે, એટલે કે એને ઓળખવા વપરાતો આંકડો.
Processes ને તમે Operating Systems માં એક વિચાર તરીકે મળી ચૂક્યા છો. અહીં તમે એમને હાથે વશમાં રાખતાં શીખો છો: શું ચાલી રહ્યું છે એ જોવું, terminal થંભાવ્યા વગર લાંબાં કામ શરૂ કરવાં, અને બગડેલા process ને બંધ કરવો. આ પાઠ એ આખો ઓજારપેટીનો ભાગ આવરી લે છે.
Theory
Foreground અને background
મૂળભૂત રીતે command foreground માં ચાલે છે: એ તમારું terminal પકડી લે છે, અને એ પૂરો ન થાય ત્યાં સુધી તમે કશું ટાઇપ કરી શકતા નથી, ફક્ત રાહ જ જુઓ છો. ઝડપી commands માટે એ ઠીક છે, પણ મિનિટો સુધી ચાલતા કામ માટે એ કંટાળાજનક છે.
પાછળ ampersand `&` ઉમેરો એટલે command એને બદલે background માં ચાલે છે: એ શરૂ થાય છે, shell એનો PID છાપે છે, અને તમારો prompt તરત પાછો આવી જાય છે જેથી તમે કામ ચાલુ રાખી શકો. દાખલા તરીકે sleep 60 & background માં 60 સેકંડનું ટાઇમર શરૂ કરે છે અને prompt તરત જ તમને પાછો સોંપી દે છે. પછી તમે આવાં કામ jobs થી તપાસી શકો છો અને kill થી બંધ કરી શકો છો.
At a glance
| Command | એ શું કરે છે |
|---|---|
| ps | ચાલી રહેલા processes ની યાદી આપે છે (એમના PID સાથે) |
| command & | Command ને background માં ચલાવે છે; prompt તરત પાછો આવે છે |
| jobs | આ shell માં ચાલતાં background નાં કામોની યાદી આપે છે |
| Ctrl+Z | અત્યારના foreground કામને થંભાવે છે |
| bg / fg | કામને background માં ફરી ચલાવે / એને foreground માં પાછું લાવે |
| kill PID | એ PID વાળા process ને બંધ કરવા signal મોકલે છે |
| sleep N | N સેકંડ થોભે છે (scripts માં કામનું) |
Practical
Background નું કામ શરૂ કરવું અને બંધ કરવું (ચકાસાયેલું)
$ sleep 60 & # start a 60-second process in the background
[1] 4231 # shell reports job number [1] and PID 4231
$ ps # see it running
PID TTY TIME CMD
4231 pts/0 00:00:00 sleep
$ kill 4231 # politely ask it to stop
$ jobs
[1]+ Terminated sleep 60Formula
Foreground રોકે છે, background છૂટા કરે છે
મુખ્ય ભેદ આ છે: foreground નું કામ પૂરું ન થાય ત્યાં સુધી તમારું terminal પકડી રાખે છે; background નું કામ (& થી શરૂ કરેલું) એ ચાલતું હોય ત્યારે પણ તમને કામ કરવા દે છે.
જો ભૂલથી લાંબું કામ foreground માં શરૂ કરી બેઠા હો, તો Ctrl+Z દબાવીને એને થંભાવો, અને પછી bg લખો જેથી એ background માં આગળ ચાલે અને તમારો prompt છૂટો થાય. પછીથી fg એને foreground માં પાછું લાવે છે. Foreground અને background નો આ ખેલ જ તમને નવી windows ખોલ્યા વગર એક જ terminal માંથી અનેક કામ સંભાળવા દે છે.
Quiz
તમે લાંબો command ચલાવો છો અને પાછળ & ઉમેરો છો, જેમ કે ./backup.sh & . શું થશે?
- Command ચાલે એ પહેલાં જ ભૂંસાઈ જાય છે
- Command background માં ચાલે છે અને તમારો shell prompt તરત પાછો આવે છે, એટલે તમે કામ ચાલુ રાખી શકો છો
- Command foreground માં ચાલે છે અને પૂરો થાય ત્યાં સુધી terminal રોકી રાખે છે
- & એ પરિણામને મૂળાક્ષરના ક્રમમાં ગોઠવે છે
Show the answer
Command background માં ચાલે છે અને તમારો shell prompt તરત પાછો આવે છે, એટલે તમે કામ ચાલુ રાખી શકો છો
પાછળ & ઉમેરવાથી command background માં ચાલે છે: એ શરૂ થાય છે, shell એનો job number અને PID છાપે છે, અને તમારો prompt તરત પાછો આવે છે, એટલે એ કામ કરતું હોય ત્યારે પણ તમે બીજા commands ચલાવી શકો છો. વિકલ્પ A ખોટો છે: & કશું ભૂંસતું નથી; command સામાન્ય રીતે જ ચાલે છે, ફક્ત background માં. વિકલ્પ C એ & વગર ચલાવવાનું વર્ણન કરે છે, એટલે કે terminal ને પકડી રાખતું foreground નું વર્તન, જેને & ટાળે છે. વિકલ્પ D બનાવટી છે; & ને ગોઠવણી સાથે કશી લેવાદેવા નથી. લાંબાં કામ (backups, downloads) માટે & વાપરો જેથી તમે આગળ વધો ત્યારે એ ચાલતાં રહે; એમને jobs થી તપાસો અને જરૂર પડે તો kill થી બંધ કરો.
Think first
kill અને kill -9 વચ્ચે ફેર શું છે?
kill PID સામાન્ય રીતે process બંધ કરી દે છે, છતાં લોકો ક્યારેક kill -9 વાપરે છે. ફેર શું છે, અને હંમેશા -9 કેમ ન વાપરવું? વિચારીને પછી tap કરો.
Show the answer
kill એ process ને એક signal મોકલે છે, અને ફેર એટલો જ છે કે એ signal કેટલો બળપ્રયોગ કરે છે. સાદો kill PID મૂળભૂત TERM signal (ક્રમાંક 15) મોકલે છે, જે process ને નમ્રતાથી બંધ થવાનું કહે છે. પહેલી પસંદગી તરીકે આ જ યોગ્ય છે, કારણ કે એ program ને પોતાનું આટોપી લેવા દે છે: પોતાની files સાચવવી, database માં લખવાનું પૂરું કરવું, સાધનો છોડી દેવાં અને સભ્યતાથી બહાર નીકળવું. મોટા ભાગના processes એનું પાલન કરે છે. પણ ક્યારેક process ભરાઈ પડ્યો હોય કે TERM ને અવગણતો હોય, ત્યારે kill -9 PID એ KILL signal (ક્રમાંક 9) મોકલે છે, જે kernel પાસે process ને તાત્કાલિક બંધ કરાવે છે, અને આટોપી લેવાની કોઈ તક રહેતી નથી. એ બળપ્રયોગ જ કારણ છે કે પહેલેથી -9 તરફ હાથ ન લંબાવવો જોઈએ: process ને સાચવવાની કે સમેટવાની તક મળતી નથી, એટલે અધૂરી લખાયેલી files કે બગડેલા data નું જોખમ રહે છે. સારી ટેવ આ છે: પહેલાં સાદો kill અજમાવો (નમ્ર), થોડી ક્ષણ રાહ જુઓ, અને process ખરેખર બંધ થવાની ના પાડે તો જ kill -9 સુધી જાઓ. બળ વાપરતાં પહેલાં વિનંતી કરો: પહેલાં TERM, અને KILL ફક્ત છેલ્લા ઉપાય તરીકે.
Summary
Key takeaways
- Process એટલે ચાલી રહેલો program; kernel દરેકને એક અનન્ય Process ID (PID) આપે છે.
- ps ચાલી રહેલા processes અને એમના PID ની યાદી આપે છે; jobs આ shell નાં background નાં કામોની યાદી આપે છે.
- Foreground નો command પૂરો ન થાય ત્યાં સુધી terminal રોકી રાખે છે; પાછળ & ઉમેરવાથી એ background માં ચાલે છે અને prompt તરત પાછો આવે છે.
- Ctrl+Z એ foreground નું કામ થંભાવે છે; bg એને background માં આગળ ચલાવે છે; fg એને foreground માં પાછું લાવે છે.
- kill PID એ process ને signal મોકલીને બંધ કરે છે.
- સાદો kill નમ્ર TERM (15) મોકલે છે જેથી process પોતાનું આટોપી શકે; kill -9 એ KILL મોકલે છે અને તાત્કાલિક બંધ કરાવે છે (છેલ્લો ઉપાય).
- યાદ રાખવાની કડી: background માટે &, જોવા માટે ps, બંધ કરવા માટે kill; પહેલાં TERM, ભરાઈ પડે તો જ -9.