ഈ വിഭാഗത്തിൽ, വരുന്ന സിഗ്നലുകൾ (ഇൻ്ററപ്റ്റുകൾ പോലുള്ളവ) പ്രോസസ്സ് ചെയ്യുന്ന പ്രക്രിയ ഞങ്ങൾ ഘട്ടം ഘട്ടമായി പരിഗണിക്കും പുറം ലോകം, അതുപോലെ പ്രോഗ്രാം പിശകുകൾ. പ്രോഗ്രാമിലെ പിശകുകൾ പ്രധാനമായും തെറ്റായതിനാലാണ് ഉണ്ടാകുന്നത്

നിർദ്ദിഷ്ട നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കുമ്പോൾ അല്ലെങ്കിൽ ഫ്ലോട്ടിംഗ് പോയിൻ്റ് പ്രവർത്തനങ്ങൾ കാരണം അനുചിതമായ മെമ്മറി ആക്‌സസ്സ്. പുറം ലോകത്ത് നിന്ന് വരുന്ന ഏറ്റവും സാധാരണമായ സിഗ്നലുകൾ: തടസ്സപ്പെടുത്തുക(തടസ്സപ്പെടുത്തുക) - നിങ്ങൾ ഒരു കീ അമർത്തുമ്പോൾ ഈ സിഗ്നൽ അയയ്ക്കുന്നു DEL; പുറത്ത്(ഉപേക്ഷിക്കുക) - FS എന്ന ചിഹ്നത്താൽ സൃഷ്ടിച്ചത് ( ctl-\); ഷട്ട് ഡൗൺ(മാറ്റിവയ്ക്കുക) - ടെലിഫോൺ ഹാംഗ് അപ്പ് ചെയ്യുന്നതിലൂടെ സംഭവിക്കുന്നത്, കൂടാതെ പൂർത്തീകരണം(അവസാനിപ്പിക്കുക) – കിൽ കമാൻഡ് വഴി ജനറേറ്റ് ചെയ്തത്. മേൽപ്പറഞ്ഞ ഇവൻ്റുകളിലൊന്ന് സംഭവിക്കുമ്പോൾ, ആ ടെർമിനലിൽ നിന്ന് പ്രവർത്തിക്കുന്ന എല്ലാ പ്രക്രിയകളിലേക്കും ഒരു സിഗ്നൽ അയയ്‌ക്കും, കൂടാതെ പ്രസ്‌താവിക്കുന്ന കൺവെൻഷനുകൾ ഇല്ലെങ്കിൽ, സിഗ്നൽ പ്രക്രിയ അവസാനിപ്പിക്കും. മിക്ക സിഗ്നലുകളും ഒരു മെമ്മറി ഡംപ് സൃഷ്ടിക്കുന്നു, അത് ഡീബഗ്ഗിംഗിന് ആവശ്യമായി വന്നേക്കാം. (adb(1), sdb(l) എന്നിവ കാണുക.)

സിഗ്നൽ സിസ്റ്റം കോൾ ഡിഫോൾട്ട് പ്രവർത്തനം മാറ്റുന്നു. ഇതിന് രണ്ട് ആർഗ്യുമെൻ്റുകളുണ്ട്: ആദ്യത്തേത് സിഗ്നലിനെ നിർവചിക്കുന്ന ഒരു സംഖ്യയാണ്, രണ്ടാമത്തേത് ഒന്നുകിൽ ഫംഗ്ഷൻ്റെ വിലാസം, അല്ലെങ്കിൽ സിഗ്നൽ അവഗണിക്കാനോ സ്ഥിരസ്ഥിതി പ്രവർത്തനങ്ങൾ പുനഃസ്ഥാപിക്കാനോ നിർദ്ദേശിക്കുന്ന കോഡ്. ഫയൽ വിവിധ വാദങ്ങളുടെ വിവരണങ്ങൾ അടങ്ങിയിരിക്കുന്നു. അതിനാൽ,

#ഉൾപ്പെടുന്നു

സിഗ്നൽ(SIGINT, SIG_IGN);

തടസ്സം അവഗണിക്കപ്പെടുന്നതിന് കാരണമാകുന്നു

സിഗ്നൽ (SIGINT, SIG_DFL);

സ്ഥിരസ്ഥിതി പ്രവർത്തനം പുനഃസ്ഥാപിക്കുന്നു - പ്രക്രിയ അവസാനിപ്പിക്കുന്നു. എല്ലാ സാഹചര്യങ്ങളിലും, സിഗ്നൽ സിഗ്നലിൻ്റെ മുൻ മൂല്യം നൽകുന്നു. രണ്ടാമത്തെ ആർഗ്യുമെൻ്റ് ഒരു ഫംഗ്‌ഷൻ്റെ പേരാണെങ്കിൽ (അത് അതേപടി പ്രഖ്യാപിക്കണം ഉറവിട ഫയൽ), അപ്പോൾ ഒരു സിഗ്നൽ സംഭവിക്കുമ്പോൾ അത് വിളിക്കപ്പെടും. ഈ സവിശേഷതയുടെ ഏറ്റവും സാധാരണമായ ഉപയോഗം, ഒരു താൽക്കാലിക ഫയൽ ഇല്ലാതാക്കുന്നത് പോലെ, പുറത്തുകടക്കാൻ തയ്യാറെടുക്കാൻ പ്രോഗ്രാമിനെ അനുവദിക്കുക എന്നതാണ്:

#ഉൾപ്പെടുന്നു

char *tempfile = "temp.XXXXXX";

extern onintr();

mktemp(tempfile);

/* പ്രോസസ്സിംഗ്... */ എക്സിറ്റ്(0);

onintr() /* തടസ്സപ്പെട്ടാൽ മായ്ക്കുക */

അൺലിങ്ക് (ടെംഫിൽ); പുറത്തുകടക്കുക (1);

എന്തുകൊണ്ടാണ് നമ്മൾ വീണ്ടും സിഗ്നൽ പരിശോധിച്ച് പ്രധാനമായി വിളിക്കേണ്ടത്? സിഗ്നലുകൾ അയച്ചതായി ഓർക്കുക എല്ലാംഈ ടെർമിനലിൽ പ്രവർത്തിക്കുന്ന പ്രക്രിയകൾ. അതനുസരിച്ച്, ഒരു പ്രോഗ്രാം ഇൻ്ററാക്ടീവ് ആയി പ്രവർത്തിക്കാത്തപ്പോൾ (എന്നാൽ & കൂടെ), കമാൻഡ് പ്രോസസർ അതിനെ ഇൻ്ററപ്റ്റുകൾ അവഗണിക്കാൻ അനുവദിക്കുന്നു, അതിനാൽ ഇൻ്ററാക്ടീവ് അല്ലാത്ത ആവശ്യങ്ങൾക്കായി ഉദ്ദേശിച്ചിട്ടുള്ള തടസ്സങ്ങളാൽ പ്രോഗ്രാം നിർത്തില്ല. പശ്ചാത്തല പ്രക്രിയകൾ. എല്ലാ തടസ്സങ്ങളും onintr-ലേക്ക് അയയ്‌ക്കണമെന്ന അറിയിപ്പോടെയാണ് പ്രോഗ്രാം ആരംഭിക്കുന്നതെങ്കിൽ, എന്തുതന്നെയായാലും, ഇത് ശ്രമത്തെ നിരാകരിക്കുന്നു. കമാൻഡ് പ്രൊസസർപശ്ചാത്തലത്തിൽ പ്രവർത്തിക്കുന്ന ഒരു പ്രോഗ്രാം പരിരക്ഷിക്കുക.

മുകളിൽ അവതരിപ്പിച്ച പരിഹാരം ഇൻ്ററപ്റ്റ് മാനേജ്‌മെൻ്റിൻ്റെ നില പരിശോധിക്കാനും തടസ്സങ്ങൾ മുമ്പ് അവഗണിച്ചിട്ടുണ്ടെങ്കിൽ അവ അവഗണിക്കുന്നത് തുടരാനും നിങ്ങളെ അനുവദിക്കുന്നു. സിഗ്നൽ മടങ്ങുന്നു എന്ന വസ്തുത കോഡ് കണക്കിലെടുക്കുന്നു മുൻ സംസ്ഥാനംനിർദ്ദിഷ്ട സിഗ്നൽ. സിഗ്നലുകൾ മുമ്പ് അവഗണിച്ചിട്ടുണ്ടെങ്കിൽ, പ്രക്രിയ അവ അവഗണിക്കുന്നത് തുടരും; അല്ലാത്തപക്ഷം അവരെ തടയണം.

കൂടുതൽ സങ്കീർണ്ണമായ ഒരു പ്രോഗ്രാമിന് ഇൻ്ററപ്റ്റിനെ തടസ്സപ്പെടുത്താനും പുരോഗതിയിലുള്ള പ്രവർത്തനം റദ്ദാക്കാനും സ്വന്തം കമാൻഡ് ലൂപ്പിലേക്ക് മടങ്ങാനുമുള്ള ഒരു അഭ്യർത്ഥനയായി അതിനെ വ്യാഖ്യാനിക്കാൻ ആഗ്രഹിച്ചേക്കാം. ഉദാഹരണത്തിന് ഒരു വേഡ് പ്രോസസർ എടുക്കുക: വളരെ നേരം ടൈപ്പിംഗ് തടസ്സപ്പെടുത്തുന്നത് പ്രോഗ്രാമിൽ നിന്ന് പുറത്തുകടക്കുന്നതിനും നിങ്ങളുടെ എല്ലാ ജോലികളും നഷ്‌ടപ്പെടുന്നതിനും കാരണമാകരുത്. ഈ സാഹചര്യത്തിൽ, നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന കോഡ് എഴുതാം:

#ഉൾപ്പെടുന്നു

#ഉൾപ്പെടുന്നു jmp_buf sjbuf;

എങ്കിൽ (സിഗ്നൽ(SIGINT, SIG_IGN) != SIG_IGN) സിഗ്നൽ(SIGINT, onintr);

setjmp(sjbuf); /* സ്റ്റാക്കിലെ നിലവിലെ സ്ഥാനം സംരക്ഷിക്കുക */ (;;) (

/* പ്രധാന പ്രോസസ്സിംഗ് ലൂപ്പ് */

onintr() /* തടസ്സപ്പെട്ടാൽ പുനഃസജ്ജമാക്കുക */

സിഗ്നൽ(SIGINT, onintr); /* അടുത്ത തടസ്സത്തിനായി പുനഃസജ്ജമാക്കുക */ printf("\nതടസ്സം\n");

longjmp(sjbuf, 0); /* സംരക്ഷിച്ച അവസ്ഥയിലേക്ക് മടങ്ങുക */)

setjmp.h എന്ന ഫയൽ, jmp_buf എന്ന തരത്തെ സ്റ്റാക്ക് പൊസിഷൻ സംഭരിക്കാൻ കഴിയുന്ന ഒരു വസ്തുവായി പ്രഖ്യാപിക്കുന്നു; sjbuf ഇത്തരത്തിലുള്ള ഒരു വസ്തുവായി പ്രഖ്യാപിച്ചിരിക്കുന്നു. setjmp(3) ഫംഗ്‌ഷൻ പ്രോഗ്രാം എവിടെ എക്‌സിക്യൂട്ട് ചെയ്യുന്നു എന്നതിൻ്റെ ഒരു റെക്കോർഡ് സൂക്ഷിക്കുന്നു. വേരിയബിൾ മൂല്യങ്ങൾ സംരക്ഷിച്ചിട്ടില്ല. ഒരു തടസ്സം സംഭവിക്കുമ്പോൾ, onintr പ്രോഗ്രാമിലേക്ക് ഒരു കോൾ ആരംഭിക്കുന്നു, അതിന് ഒരു സന്ദേശം പ്രിൻ്റ് ചെയ്യാനോ ഫ്ലാഗുകൾ സജ്ജീകരിക്കാനോ മറ്റെന്തെങ്കിലും ചെയ്യാനോ കഴിയും. longjmp ഫംഗ്‌ഷൻ setjmp-ൽ സംഭരിച്ചിരിക്കുന്ന ഒബ്‌ജക്‌റ്റ് സ്വീകരിക്കുകയും setjmp-ലേക്കുള്ള കോളിന് ശേഷം പ്രോഗ്രാമിലെ പോയിൻ്റിലേക്ക് നിയന്ത്രണം തിരികെ നൽകുകയും ചെയ്യുന്നു. അങ്ങനെ, പ്രധാന ലൂപ്പ് നൽകിയ പ്രധാന പ്രോഗ്രാമിലെ പോയിൻ്റിലേക്ക് നിയന്ത്രണം (സ്റ്റാക്ക് സ്ഥാനവും) മടങ്ങുന്നു.

തടസ്സം സംഭവിച്ചതിന് ശേഷം സിഗ്നൽ വീണ്ടും onintr ആയി സജ്ജീകരിച്ചിരിക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക. സിഗ്നലുകൾ ലഭിക്കുമ്പോൾ, സ്വതവേയുള്ള പ്രവർത്തനം സ്വയമേവ പുനഃസ്ഥാപിക്കുന്നതിനാൽ ഇത് ആവശ്യമാണ്.

ചില പ്രോഗ്രാമുകൾ ഒരു ഘട്ടത്തിലും നിർത്താൻ കഴിയില്ല, ഉദാഹരണത്തിന് പ്രോസസ്സിംഗ് സമയത്ത് സങ്കീർണ്ണമായ ഘടനഡാറ്റ, അതിനാൽ സിഗ്നലുകൾ കണ്ടുപിടിക്കാൻ കഴിയേണ്ടത് അത്യാവശ്യമാണ്. ഒരുപക്ഷേ അടുത്ത പരിഹാരം- എക്സിറ്റ് അല്ലെങ്കിൽ ലോംഗ്‌ജെഎംപി വിളിക്കുന്നതിനുപകരം ഞങ്ങൾക്ക് ഇൻ്ററപ്റ്റ് ഹാൻഡ്‌ലർ ഫ്ലാഗ് സജ്ജീകരിച്ച് മടങ്ങേണ്ടതുണ്ട്. തടസ്സപ്പെട്ടിടത്ത് നിന്ന് നിർവ്വഹണം തുടരും, തടസ്സപ്പെട്ട ഫ്ലാഗ് പിന്നീട് പരിശോധിക്കാവുന്നതാണ്.

ഈ സമീപനത്തിന് ഒരു ബുദ്ധിമുട്ട് ഉണ്ട്. ഇൻ്ററപ്റ്റ് അയയ്‌ക്കുമ്പോൾ പ്രോഗ്രാം ടെർമിനലിൽ നിന്ന് വായിക്കുന്നതായി നമുക്ക് അനുമാനിക്കാം. നിർദ്ദിഷ്‌ട ദിനചര്യയെ ശരിയായി വിളിക്കുന്നു, ഫ്ലാഗുകൾ സജ്ജീകരിച്ച് മടങ്ങുന്നു. മുകളിൽ പ്രസ്താവിച്ചതുപോലെ, അതായത്, പ്രോഗ്രാം "തടസ്സമുണ്ടായ ഘട്ടം മുതൽ" എക്സിക്യൂഷൻ പുനരാരംഭിക്കും, തുടർന്ന് ഉപയോക്താവ് ഒരു പുതിയ ലൈൻ ടൈപ്പ് ചെയ്യുന്നതുവരെ പ്രോഗ്രാം ടെർമിനലിൽ നിന്ന് വായന തുടരേണ്ടതുണ്ട്. ഈ സ്വഭാവം ആശയക്കുഴപ്പമുണ്ടാക്കാം, കാരണം പ്രോഗ്രാം എന്താണ് വായിക്കുന്നതെന്ന് ഉപയോക്താവിന് അറിയില്ലായിരിക്കാം, മാത്രമല്ല സിഗ്നൽ ഉടൻ പ്രാബല്യത്തിൽ വരാൻ അവർ താൽപ്പര്യപ്പെടുകയും ചെയ്യും. ഈ പ്രശ്നം പരിഹരിക്കുന്നതിന്, സിസ്റ്റം റീഡ് പൂർത്തിയാക്കുന്നു, എന്നാൽ എന്താണ് സംഭവിച്ചതെന്ന് സൂചിപ്പിക്കുന്ന ഒരു പിശക് നില; ഒരു അബോർഡ് സിസ്റ്റം കോളിനെ സൂചിപ്പിക്കാൻ errno.h-ൽ നിർവചിച്ചിരിക്കുന്ന EINTR ആയി errno സജ്ജീകരിച്ചിരിക്കുന്നു.

അതിനാൽ, സിഗ്നലുകളെ തടസ്സപ്പെടുത്തുകയും അവയ്ക്ക് ശേഷം പുനരാരംഭിക്കുകയും ചെയ്യുന്ന പ്രോഗ്രാമുകൾ തടസ്സപ്പെട്ട സിസ്റ്റം കോളുകൾ മൂലമുണ്ടാകുന്ന "പിശകുകൾ"ക്കായി തയ്യാറാക്കണം. (ടെർമിനൽ റീഡ്, കാത്തിരിപ്പ്, താൽക്കാലികമായി നിർത്തൽ എന്നിവയാണ് ശ്രദ്ധിക്കേണ്ട സിസ്റ്റം കോളുകൾ.) അത്തരമൊരു പ്രോഗ്രാമിന് സ്റ്റാൻഡേർഡ് ഇൻപുട്ട് വായിക്കാൻ താഴെയുള്ള കോഡ് ഉപയോഗിക്കാം:

#ഉൾപ്പെടുന്നു ബാഹ്യ അന്തർഭാഗം തെറ്റാണ്;

എങ്കിൽ (വായിക്കുക(0, &c, 1)<= 0) /* EOF или прерывание */

എങ്കിൽ (errno == EINTR) ( /* EOF തടസ്സം കാരണം */ തെറ്റ് = 0; /* അടുത്ത തവണ പുനഃസജ്ജമാക്കുക */

) വേറെ ( /* ഫയലിൻ്റെ യഥാർത്ഥ അവസാനം */

സിഗ്നൽ തടസ്സപ്പെടുത്തൽ മറ്റ് പ്രോഗ്രാമുകളുടെ നിർവ്വഹണവുമായി സംയോജിപ്പിച്ചിട്ടുണ്ടെങ്കിൽ നിങ്ങൾ ശ്രദ്ധിക്കേണ്ട അവസാന സൂക്ഷ്മത. പ്രോഗ്രാം ഇൻ്ററപ്റ്റുകൾ കൈകാര്യം ചെയ്യുന്നുവെന്നും കൂടാതെ, മറ്റ് പ്രോഗ്രാമുകൾ എക്സിക്യൂട്ട് ചെയ്യാൻ കഴിയുന്ന ഒരു രീതി (എഡിയിൽ ഉള്ളത് പോലെ) അടങ്ങിയിട്ടുണ്ടെന്നും നമുക്ക് അനുമാനിക്കാം. അപ്പോൾ കോഡ് ഇതുപോലെ കാണപ്പെടും:

എങ്കിൽ (ഫോർക്ക്() == 0) execlp(...);

സിഗ്നൽ(SIGINT, SIG_IGN); /* പൂർവ്വികർ തടസ്സങ്ങളെ അവഗണിക്കുന്നു */

കാത്തിരിക്കുക (& നില); /* കുട്ടി പ്രവർത്തിക്കുമ്പോൾ */ സിഗ്നൽ(SIGINT, onintr); /* തടസ്സങ്ങൾ പുനഃസ്ഥാപിക്കുക */

എന്തുകൊണ്ടാണ് ഇത് അങ്ങനെ? നിങ്ങളുടെ എല്ലാ പ്രക്രിയകളിലേക്കും സിഗ്നലുകൾ അയച്ചു. എഡിറ്റർ ചെയ്യുന്നതുപോലെ, നിങ്ങൾ വിളിച്ച പ്രോഗ്രാം അതിൻ്റേതായ തടസ്സങ്ങൾ കൈകാര്യം ചെയ്യുന്നുവെന്ന് നമുക്ക് അനുമാനിക്കാം. നിങ്ങൾ ചൈൽഡ് പ്രോഗ്രാമിനെ തടസ്സപ്പെടുത്തുകയാണെങ്കിൽ, അതിന് സിഗ്നൽ ലഭിക്കുകയും അതിൻ്റെ പ്രധാന ലൂപ്പിലേക്ക് മടങ്ങുകയും ചെയ്യും, ഒരുപക്ഷേ നിങ്ങളുടെ ടെർമിനൽ വായിക്കുകയും ചെയ്യും. എന്നാൽ കോളിംഗ് പ്രോഗ്രാം ചൈൽഡ് പ്രോഗ്രാമിനായുള്ള കാത്തിരിപ്പിൽ നിന്ന് ഉണരുകയും നിങ്ങളുടെ ടെർമിനൽ വായിക്കുകയും ചെയ്യും. രണ്ട് ടെർമിനൽ റീഡിംഗ് പ്രോസസ്സുകൾ ഉള്ളത് കാര്യങ്ങളെ ആശയക്കുഴപ്പത്തിലാക്കുന്നു, കാരണം ഓരോ വരി ഇൻപുട്ടും ഏത് പ്രോഗ്രാമിന് ലഭിക്കുമെന്ന് തീരുമാനിക്കാൻ സിസ്റ്റം യഥാർത്ഥത്തിൽ ഒരു നാണയം ഫ്ലിപ്പുചെയ്യുന്നു. ഇത് ഒഴിവാക്കാൻ, കുട്ടി എക്സിക്യൂട്ട് ചെയ്യുന്നത് വരെ പാരൻ്റ് പ്രോഗ്രാം തടസ്സങ്ങൾ അവഗണിക്കണം. ഈ നിഗമനം സിസ്റ്റത്തിലെ സിഗ്നൽ പ്രോസസ്സിംഗിൽ പ്രതിഫലിക്കുന്നു:

#ഉൾപ്പെടുന്നു

സിസ്റ്റം(കൾ) /* എക്സിക്യൂട്ട് കമാൻഡ് ലൈൻ s */ char *s;

int സ്റ്റാറ്റസ്, pid, w, tty;

int (*istat)(), (*qstat)();

എങ്കിൽ ((പിഡ് = ഫോർക്ക്()) == 0) (

execlp("sh", "sh", "–c", s, (char *) 0); പുറത്തുകടക്കുക (127);

istat = സിഗ്നൽ (SIGINT, SIG_IGN); qstat = സിഗ്നൽ (SIGQUIT, SIG_IGN);

അതേസമയം ((w = കാത്തിരിക്കുക(& സ്റ്റാറ്റസ്)) != pid && w != –1)

എങ്കിൽ (w == –1) നില = –1;

സിഗ്നൽ (SIGINT, istat); സിഗ്നൽ (SIGQUIT, qstat); തിരികെ സ്റ്റാറ്റസ്;

ഒരു വശത്ത്, സിഗ്നൽ ഫംഗ്‌ഷന് പ്രത്യക്ഷത്തിൽ അൽപ്പം വിചിത്രമായ രണ്ടാമത്തെ ആർഗ്യുമെൻ്റ് ഉണ്ട്. ഇത് യഥാർത്ഥത്തിൽ ഒരു പൂർണ്ണസംഖ്യ നൽകുന്ന ഒരു ഫംഗ്‌ഷനിലേക്കുള്ള ഒരു പോയിൻ്ററാണ്, മാത്രമല്ല ഇത് സിഗ്-നൽ ഫംഗ്‌ഷൻ്റെ തരം കൂടിയാണ്. SIG_IGN, SIG_DFL എന്നീ രണ്ട് മൂല്യങ്ങളും ശരിയായ തരത്തിലുള്ളതാണ്, എന്നാൽ സാധ്യമായ യഥാർത്ഥ ഫംഗ്‌ഷനുകളൊന്നും പൊരുത്തപ്പെടാത്തതിനാൽ തിരഞ്ഞെടുത്തിരിക്കുന്നു. പ്രത്യേക താൽപ്പര്യമുള്ളവർക്കായി, PDP-11, VAX എന്നിവയ്ക്കായി അവ എങ്ങനെ വിവരിച്ചിരിക്കുന്നു എന്നതിൻ്റെ ഒരു ഉദാഹരണം ഇതാ; വിവരണങ്ങൾ സിഗ്നലിൻ്റെ ഉപയോഗം പ്രോത്സാഹിപ്പിക്കുന്ന തരത്തിൽ വെറുപ്പുളവാക്കുന്നതായിരിക്കണം.h.

#SIG_DFL (int (*)())0 നിർവചിക്കുക

#നിർവ്വചിക്കുക SIG_IGN (int (*)())1

അലാറം സിഗ്നലുകൾ

സിസ്റ്റം കോൾ അലാറം( എൻ) വഴി നിങ്ങളുടെ പ്രോസസ്സിലേക്ക് ഒരു SIGALRM സിഗ്നൽ അയയ്‌ക്കുന്നതിന് കാരണമാകുന്നു എൻസെക്കൻ്റുകൾ ഉചിതമായ സമയത്തിനുള്ളിൽ എന്തെങ്കിലും സംഭവിച്ചുവെന്ന് ഉറപ്പാക്കാൻ ഒരു അലാറം സിഗ്നൽ ഉപയോഗിക്കാം. എന്തെങ്കിലും സംഭവിച്ചാൽ, SIGALRM ഓഫാക്കാം; ഇല്ലെങ്കിൽ, ഒരു അലാറം സിഗ്നൽ സ്വീകരിച്ച് പ്രക്രിയയ്ക്ക് നിയന്ത്രണം തിരികെ നൽകാം.

സാഹചര്യം വിശദീകരിക്കുന്നതിന്, ടൈം-ഔട്ട് എന്ന് വിളിക്കുന്ന ഒരു പ്രോഗ്രാം പരിഗണിക്കുക, അത് മറ്റേതെങ്കിലും കമാൻഡ് പ്രവർത്തിപ്പിക്കുന്നു; ഈ കമാൻഡ് ഒരു നിശ്ചിത സമയത്തിനുള്ളിൽ പൂർത്തിയാക്കിയില്ലെങ്കിൽ, അലാറം ഓഫാക്കുമ്പോൾ അത് നിർത്തലാക്കും. ഉദാഹരണത്തിന്, അധ്യായം 5-ൽ നിന്നുള്ള watchfor കമാൻഡ് ഓർക്കുക. ഇത് അനിശ്ചിതമായി പ്രവർത്തിപ്പിക്കുന്നതിന് പകരം, നിങ്ങൾക്ക് ഒരു മണിക്കൂർ പരിധി സജ്ജീകരിക്കാം:

$ കാലഹരണപ്പെടൽ -3600 വാച്ച് ഫോർ ഡിഎംജി &

ടൈംഔട്ടിലുള്ള കോഡ് മുമ്പത്തെ രണ്ട് വിഭാഗങ്ങളിൽ ചർച്ച ചെയ്ത മിക്കവാറും എല്ലാം ചിത്രീകരിക്കുന്നു. ഒരു കുട്ടി സൃഷ്ടിക്കപ്പെടുന്നു; പൂർവ്വികൻ ഒരു അലാറം സ്ഥാപിച്ച് കുട്ടി അതിൻ്റെ ജോലി പൂർത്തിയാക്കുന്നതിനായി കാത്തിരിക്കുന്നു. നേരത്തെ അലാറം വന്നാൽ കുട്ടി നശിപ്പിക്കപ്പെടും. കുട്ടിയുടെ എക്സിറ്റ് സ്റ്റാറ്റസ് തിരികെ നൽകാനുള്ള ശ്രമം നടക്കുന്നു.

/* കാലഹരണപ്പെടൽ: പ്രക്രിയയ്ക്കായി ഒരു സമയ പരിധി സജ്ജീകരിക്കുന്നു */

#ഉൾപ്പെടുന്നു

#ഉൾപ്പെടുന്നു

int pid; /* ചൈൽഡ് പ്രോസസ്സ് ഐഡി */

char *progname; പ്രധാന (ആർജിസി, ആർജിവി)

int sec = 10, സ്റ്റാറ്റസ്, ഓണാലാം();

progname = argv;

എങ്കിൽ (argc > 1 && argv == '-') ( സെക്കൻ്റ് = atoi(&argv);

argc––; argv++;

എങ്കിൽ (argc< 2)

പിശക് ("ഉപയോഗം: %s [–10] കമാൻഡ്", പ്രോഗ്നെയിം); എങ്കിൽ ((pid=fork()) == 0) (

execvp(argv, &argv); പിശക് ("%s ആരംഭിക്കാൻ കഴിഞ്ഞില്ല", argv);

സിഗ്നൽ(SIGALRM, onalarm); അലാറം (സെക്കൻഡ്);

എങ്കിൽ (കാത്തിരിക്കുക(& സ്റ്റാറ്റസ്) == –1 || (സ്റ്റാറ്റസ് & 0177) != 0) പിശക് ("%s കൊല്ലപ്പെട്ടു", argv);

പുറത്തുകടക്കുക ((നില >> 8) & 0377);

onalarm() /* ഒരു അലാറം ലഭിച്ചാൽ ചൈൽഡ് പ്രോസസ്സ് അവസാനിപ്പിക്കുക */

കൊല്ലുക(pid, SIGKILL);

വ്യായാമം 7.18.ഉറക്കം എങ്ങനെയാണ് നടപ്പിലാക്കുന്നതെന്ന് നിങ്ങൾക്ക് ഊഹിക്കാൻ കഴിയുമോ? സൂചന: താൽക്കാലികമായി നിർത്തുക(2). ഏത് സാഹചര്യത്തിലാണ് (എന്തെങ്കിലും ഉണ്ടെങ്കിൽ) ഉറക്കത്തിനും അലാറത്തിനും പരസ്പരം ഇടപെടാൻ കഴിയും? ~

ചരിത്രവും ഗ്രന്ഥസൂചികയും

പുസ്തകത്തിൽ അവതരിപ്പിച്ചിട്ടില്ല വിശദമായ വിവരണം UNIX സിസ്റ്റം നടപ്പിലാക്കൽ, പ്രത്യേകിച്ച് കോഡിന് ഉടമസ്ഥാവകാശം ഉള്ളതിനാൽ. 1978 ജൂലൈയിൽ BSTJ-ൽ പ്രസിദ്ധീകരിച്ച കെൻ തോംസൻ്റെ "UNIX നടപ്പിലാക്കൽ" എന്ന പ്രബന്ധം അടിസ്ഥാന ആശയങ്ങൾ വിവരിക്കുന്നു. ഇതേ വിഷയം "യുണിക്സ് സിസ്റ്റം - ഒരു റിട്രോസ്പെക്റ്റീവ്" എന്ന ലേഖനത്തിലും ഇതേ ലക്കത്തിൽ ഉന്നയിക്കപ്പെട്ടിട്ടുണ്ട്

"BSTJ", "UNIX ടൈം ഷെയറിംഗ് സിസ്റ്റത്തിൻ്റെ പരിണാമം" ( യുണിക്സിൻ്റെ പരിണാമം- സമയം പങ്കിടൽ സംവിധാനങ്ങൾ), സ്പ്രിംഗർ-വെർലാഗ് ജേണലിലെ "ലക്ചർ നോട്ട്സ് ഇൻ കമ്പ്യൂട്ടർ സയൻസിൽ" ഭാഷാ രൂപകൽപ്പനയും പ്രോഗ്രാമിംഗ് രീതിശാസ്ത്രവും സംബന്ധിച്ച സിമ്പോസിയത്തിൻ്റെ മെറ്റീരിയലുകളിൽ പ്രസിദ്ധീകരിച്ചു.

1979-ൽ നമ്പർ 79. രണ്ട് കൃതികളും എഴുതിയത് ഡെന്നിസ് റിച്ചിയാണ്.

റീഡ്‌സ്‌ലോ പ്രോഗ്രാം കണ്ടുപിടിച്ചത് പീറ്റർ വെയ്ൻബർഗർ ആണ് ലളിതമായ പ്രതിവിധിപ്രേക്ഷകർക്ക് ഒരു ചെസ്സ് ഗെയിം കാണിക്കാൻ ബെല്ലെ പ്രോഗ്രാമുകൾഒരു ചെസ്സ് ടൂർണമെൻ്റിനിടെ കെൻ തോംസണും ജോ കോണ്ടനും. ബെല്ലെ ഗെയിം നില ഒരു ഫയലിലേക്ക് എഴുതി; വളരെയധികം വിലയേറിയ സൈക്കിളുകൾ എടുക്കുന്നത് ഒഴിവാക്കാൻ നിരീക്ഷകർ റീഡ് സ്ലോ ഉപയോഗിച്ച് ഫയൽ പോൾ ചെയ്തു. ( ഒരു പുതിയ പതിപ്പ്ബെല്ലെ ഹാർഡ്‌വെയർ അതിൻ്റെ ഹോസ്റ്റ് മെഷീനിൽ ചെറിയ കണക്കുകൂട്ടലുകൾ നടത്തുന്നു, അതിനാൽ ഈ പ്രശ്നം ഇനി നിലവിലില്ല.)

ടോം ഡഫ് സ്‌പൈം എഴുതാൻ ഞങ്ങളെ പ്രചോദിപ്പിച്ചു. ഐവർ ഡർഹാം, ഡേവിഡ് ലാംബ്, ജെയിംസ് സാക്സ് എന്നിവരുടെ ലേഖനം "ഉപയോക്തൃ ഇൻ്റർഫേസുകളിലെ അക്ഷരവിന്യാസം തിരുത്തൽ" ഉപയോക്തൃ ഇൻ്റർഫേസുകൾ 1983 ഒക്ടോബറിൽ CACM പ്രസിദ്ധീകരിച്ചത്, ഒരു ഇമെയിൽ പ്രോഗ്രാമിൻ്റെ പശ്ചാത്തലത്തിൽ അക്ഷരത്തെറ്റ് തിരുത്തൽ നടപ്പിലാക്കുന്നതിനുള്ള അൽപ്പം വ്യത്യസ്തമായ പ്രോജക്റ്റാണ്.

സിഗ്നലുകൾ സോഫ്റ്റ്‌വെയർ തടസ്സങ്ങളാണ്. UNIX, UNIX പോലുള്ള Linux, Mac OS പോലുള്ള ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിലെ പ്രക്രിയകൾ തമ്മിലുള്ള ആശയവിനിമയത്തിനായി അവ ഉപയോഗിക്കുന്നു.

1970-ൽ Bell Labs UNIX മുതൽ സിഗ്നലുകൾ ഉപയോഗത്തിലുണ്ട്, ഇപ്പോൾ POSIX സ്റ്റാൻഡേർഡ് ഔദ്യോഗികമായി നിർവചിച്ചിരിക്കുന്നു. പ്രക്രിയയിൽ ഒരു സിഗ്നൽ എത്തുമ്പോൾ, ഓപ്പറേറ്റിംഗ് സിസ്റ്റംപ്രോസസ്സ് എക്സിക്യൂഷൻ്റെ സാധാരണ ഒഴുക്കിനെ തടസ്സപ്പെടുത്തുകയും അറിയിപ്പ് നൽകുകയും ചെയ്യുന്നു.

നിങ്ങൾ ഏത് ഓപ്പറേറ്റിംഗ് സിസ്റ്റമാണ് ഉപയോഗിക്കുന്നതെന്നത് പ്രശ്നമല്ല, നിങ്ങളുടെ ആപ്ലിക്കേഷനുകൾ തടയുന്നതും ശരിയായി പ്രവർത്തിക്കാൻ വിസമ്മതിക്കുന്നതും നിങ്ങൾക്ക് തീർച്ചയായും അനുഭവപ്പെടും. യുണിക്സിൽ, ലിനക്സിൽ, പ്രക്രിയയെ ഉടനടി ഇല്ലാതാക്കാൻ നിങ്ങൾക്ക് ഉപയോഗിക്കാവുന്ന ഒരു "കിൽ" കമാൻഡ് ഉണ്ട്, പക്ഷേ അത് മാത്രമല്ല, ഞാൻ അതിനെക്കുറിച്ച് കുറച്ച് കഴിഞ്ഞ് സംസാരിക്കും. ഈ ലേഖനത്തിൽ "Unix/Linux-ൽ കിൽ കമാൻഡ്" ഞാൻ വിശദീകരിക്കുകയും അത് എങ്ങനെ ചെയ്യണമെന്ന് കാണിക്കുകയും ചെയ്യും റെഡിമെയ്ഡ് ഉദാഹരണങ്ങൾകിൽ യൂട്ടിലിറ്റിയുടെ വിവിധ കമാൻഡുകൾ.

കൽപ്പുകളും സിഗ്നലുകളും കൊല്ലുക

നിങ്ങൾ കിൽ കമാൻഡ് നൽകുമ്പോൾ, നിങ്ങൾ യഥാർത്ഥത്തിൽ സിസ്റ്റത്തിലേക്ക് ഒരു സിഗ്നൽ അയയ്ക്കുകയും തകർന്ന ആപ്ലിക്കേഷൻ അവസാനിപ്പിക്കാൻ നിർദ്ദേശിക്കുകയും ചെയ്യുന്നു. ആകെ 60 സിഗ്നലുകൾ ഉപയോഗിക്കാനാകും, എന്നാൽ നിങ്ങൾ ശരിക്കും അറിയേണ്ടത് SIGTERM (15), SIGKILL (9) എന്നിവ മാത്രമാണ്.

കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് എല്ലാ സിഗ്നലുകളും കാണാൻ കഴിയും:

# കൊല്ലുക -എൽ

എൻ്റെ MacOS-ൽ:

എല്ലാ സിഗ്നലുകളെയും കുറിച്ച് സംസാരിക്കാൻ ഞാൻ ശ്രമിക്കും, എന്നാൽ ആദ്യം നമ്മൾ ഏറ്റവും പ്രധാനപ്പെട്ടതും പതിവായി ഉപയോഗിക്കുന്നതുമായവയെക്കുറിച്ച് മാത്രമേ സംസാരിക്കൂ.

അടിസ്ഥാന സിഗ്നലുകൾ

ഇനിപ്പറയുന്ന സിഗ്നലുകൾ POSIX സ്റ്റാൻഡേർഡിൻ്റെ ഭാഗമാണ്. ഓരോ സിഗ്നലും നിർവചിച്ചിരിക്കുന്ന ഒരു മാക്രോയാണ് സിസ്റ്റം ഹെഡ്ഡർ ഫയൽ. അവ സാധാരണയായി അവയുടെ SIG പ്രിഫിക്സ് ഇല്ലാതെ ചുരുക്കിയിരിക്കുന്നു; ഉദാഹരണത്തിന് SIGHUP എന്നത് പലപ്പോഴും HUP എന്ന് വിളിക്കപ്പെടുന്നു.

SIGTERM- പ്രവർത്തിക്കുന്ന ഒരു പ്രക്രിയ നിർത്താൻ ഈ സിഗ്നൽ അഭ്യർത്ഥിക്കുന്നു. ഈ സിഗ്നൽ അവഗണിക്കാവുന്നതാണ്. പ്രക്രിയ ശരിയായി ഷട്ട് ഡൗൺ ചെയ്യാൻ സമയം നൽകിയിട്ടുണ്ട്. ഒരു പ്രോഗ്രാം നന്നായി ഷട്ട് ഡൗൺ ചെയ്യുമ്പോൾ, അതിൻ്റെ പുരോഗതി സംരക്ഷിക്കാനും വിഭവങ്ങൾ സ്വതന്ത്രമാക്കാനും സമയം നൽകിയിട്ടുണ്ടെന്നാണ് അതിനർത്ഥം. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, അത് പ്രക്രിയ അവസാനിപ്പിക്കാൻ "നിർബന്ധിച്ചില്ല".

SIGKILL- SIGKILL സിഗ്നൽ അതിൻ്റെ പ്രവർത്തനം ഉടനടി നിർത്തുന്നതിന് കാരണമാകുന്നു. പ്രോഗ്രാമിന് ഈ സിഗ്നൽ അവഗണിക്കാൻ കഴിയില്ല. സംരക്ഷിക്കപ്പെടാത്ത പുരോഗതി നഷ്ടപ്പെടും.

"കൊല്ലുക" എന്നതിൻ്റെ വാക്യഘടന.

കമാൻഡ് വാക്യഘടന ഇതാണ്:

# PID(കൾ) കൊല്ലുക

# കൊല്ലുക [-s] [-l] %pid

സ്ഥിരസ്ഥിതി സിഗ്നൽ (വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ) SIGTERM ആണ്. ഈ സിഗ്നൽ സഹായിക്കാതിരിക്കുകയും പ്രവർത്തിക്കാതിരിക്കുകയും ചെയ്യുമ്പോൾ, ഈ പ്രക്രിയ നിർബന്ധിതമായി അവസാനിപ്പിക്കുന്നതിന് "കൊല്ലുക" എന്നതിനായി നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന ഓപ്ഷനുകൾ ഉപയോഗിക്കാം:

# SIGKILL PID കൊല്ലുക

# കൊല്ലുക -9 PID

ഇവിടെ "-9" എന്നത് SIGKILL സിഗ്നലിനെ സൂചിപ്പിക്കുന്ന പതാകയാണ്.

നിങ്ങൾ ഒഴിവാക്കാൻ ആഗ്രഹിക്കുന്ന ആപ്ലിക്കേഷനിൽ എന്ത് PID ഉപയോഗിക്കണമെന്ന് നിങ്ങൾക്കറിയില്ലെങ്കിൽ, കമാൻഡ് പ്രവർത്തിപ്പിക്കുക:

$ps -aux

നിങ്ങൾക്ക് അറിയാമെങ്കിൽ നിർദ്ദിഷ്ട ആപ്ലിക്കേഷൻ(ഉദാഹരണത്തിന്, അപ്പാച്ചെ), തുടർന്ന് നിങ്ങൾക്ക് അനാവശ്യമായത് ഒഴിവാക്കാനും ഈ സേവനത്തിനായുള്ള എല്ലാ പ്രക്രിയകളും പ്രദർശിപ്പിക്കാനും കഴിയും:

$ ps -aux | grep അപ്പാച്ചെ

കൂടാതെ എല്ലാം പ്രദർശിപ്പിക്കും പ്രവർത്തിക്കുന്ന ആപ്ലിക്കേഷനുകൾഅതിൻറെ PID(കൾ) സഹിതം.

ഉദാഹരണത്തിന്, ഒരു ആപ്ലിക്കേഷൻ ഇല്ലാതാക്കാൻ, ഞാൻ ഇനിപ്പറയുന്ന കമാൻഡ് പ്രവർത്തിപ്പിക്കുന്നു:

# കൊല്ലുക -9 3629

നിങ്ങൾക്ക് ഒരേ സമയം ഒന്നിലധികം പ്രക്രിയകൾ പ്രവർത്തിക്കുന്നതിനാൽ അവ "കൊല്ലപ്പെടാം" എന്നതും ശ്രദ്ധിക്കേണ്ടതാണ്:

# കൊല്ലുക -9 PID1 PID2 PID 3

കോൺഫിഗറേഷൻ ഫയലുകൾ റീലോഡ് ചെയ്യുക അല്ലെങ്കിൽ യൂട്ടിലിറ്റികൾ പുനരാരംഭിക്കുക:

# കൊല്ലുക -1 എണ്ണം_PID

പ്രത്യേകിച്ച് ഉപയോഗപ്രദമായ സിഗ്നലുകൾ HUP, INT, കിൽ, STOP, CONT, 0 എന്നിവ ഉൾപ്പെടുന്നു.

ഓപ്ഷനുകൾ ഇവയാണ്:

-s signal_name
ഒരു നോൺ-ഡിഫോൾട്ട് സിഗ്നൽ അയയ്ക്കുന്നതിനുള്ള സിഗ്നൽ വ്യക്തമാക്കുന്ന ഒരു പ്രതീകാത്മക സിഗ്നൽ നാമം.

-എൽ
ഓപ്പറാൻറ് വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, സിഗ്നൽ പേരുകൾ കാണിക്കുക; അല്ലെങ്കിൽ, exit_status-ന് അനുയോജ്യമായ സിഗ്നലിൻ്റെ പേര് എഴുതുക.

-സിഗ്നൽ_നാമം
സ്ഥിരസ്ഥിതിയായി TERM-ലേക്ക് അയയ്‌ക്കേണ്ട സിഗ്നൽ വ്യക്തമാക്കുന്ന പ്രതീകാത്മക സിഗ്നൽ നാമം.

-സിഗ്നൽ_നമ്പർ
TERM-ലേക്ക് അയയ്‌ക്കേണ്ട ഡിഫോൾട്ട് സിഗ്നൽ വ്യക്തമാക്കുന്ന ഒരു നോൺ-നെഗറ്റീവ് ദശാംശ പൂർണ്ണസംഖ്യ.

ഇനിപ്പറയുന്ന PID-കൾക്ക് പ്രത്യേക അർത്ഥമുണ്ട്:
-1 സൂപ്പർ യൂസർ ആണെങ്കിൽ, എല്ലാ പ്രക്രിയകളിലേക്കും സിഗ്നൽ പ്രക്ഷേപണം ചെയ്യുന്നു; അല്ലെങ്കിൽ അത് എല്ലാ പ്രക്രിയകളിലേക്കും പ്രക്ഷേപണം ചെയ്യുന്നു-
ഉപയോക്താവിന് വേണ്ടി.

ഏറ്റവും സാധാരണയായി ഉപയോഗിക്കുന്ന ചില സിഗ്നലുകൾ ഇവയാണ്:

• 1 HUP (ഹാംഗ് അപ്പ്) - ഹാംഗ് അപ്പ്.
• 2 INT (തടസ്സം) - തടസ്സം.
• 3 ക്വിറ്റ് (പുറത്തുകടക്കുക) - പുറത്തുകടക്കുക.
• 6 ABRT (അലസിപ്പിക്കൽ) - തടസ്സങ്ങൾ.
• 9 കൊല്ലുക (പിടികൂടാത്ത, അവഗണിക്കാനാവാത്ത കൊല)
• 14 ALRM ( അലാറം ക്ലോക്ക്) - അലാറം.
• 15 TERM (സോഫ്റ്റ്‌വെയർ ടെർമിനേഷൻ സിഗ്നൽ) - സിഗ്നൽ അവസാനിപ്പിക്കുന്നതിനുള്ള സോഫ്റ്റ്‌വെയർ.

പികിൽ

"pkill" കമാൻഡ് നിങ്ങളെ സാധാരണ എക്സ്പ്രഷനുകളുടെയും മറ്റ് പൊരുത്തപ്പെടുന്ന മാനദണ്ഡങ്ങളുടെയും വിപുലമായ പാറ്റേണുകൾ ഉപയോഗിക്കാൻ അനുവദിക്കുന്നു. PID ഉപയോഗിക്കുന്നതിനുപകരം, പ്രോസസ്സിൻ്റെ പേര് നൽകി നിങ്ങൾക്ക് ഇപ്പോൾ ആപ്ലിക്കേഷൻ ഇല്ലാതാക്കാം. ഉദാഹരണത്തിന്, ഫയർഫോക്സ് ബ്രൗസർ ഇല്ലാതാക്കാൻ, കമാൻഡ് പ്രവർത്തിപ്പിക്കുക:

#pkill Firefox

കാരണം അത് പാറ്റേണുമായി പൊരുത്തപ്പെടുന്നു പതിവ് ആവിഷ്കാരം, നിങ്ങൾക്ക് ഈ പ്രക്രിയയുടെ പേരിൻ്റെ ഒരു ഭാഗം കൂടി നൽകാം:

#pkillfire

തെറ്റായ പ്രക്രിയകൾ "കൊല്ലുന്നത്" ഒഴിവാക്കാൻ, നിങ്ങൾക്ക് "pgrep -l [process_name]" യോഗ്യമായ പ്രക്രിയകൾ ലിസ്റ്റ് ചെയ്യാൻ കഴിയും.

pkill കമാൻഡിന് നിരവധി ഓപ്ഷനുകൾ ഉണ്ട്, ഉദാഹരണത്തിന് നിങ്ങൾ "-u" ഓപ്ഷൻ വ്യക്തമാക്കിയാൽ അത് ഒരു ഉപയോക്തൃനാമമോ ഐഡിയോ വ്യക്തമാക്കാൻ നിങ്ങളെ അനുവദിക്കും. ഈ ഉദാഹരണത്തിൽ, 'ആരും' എന്ന ഉപയോക്താവിൻ്റെ ഉടമസ്ഥതയിലുള്ള എല്ലാ പ്രക്രിയകളിലേക്കും ഞങ്ങൾ TERM സിഗ്നൽ അയയ്ക്കുന്നു:

# pkill -u ആരും

എല്ലാവരെയും കൊല്ലൂ

PID- ന് പകരം Killall പ്രോസസ്സിൻ്റെ പേര് ഉപയോഗിക്കുന്നു, കൂടാതെ ഇത് അതേ പേരിൽ തന്നെ പ്രോസസ്സിൻ്റെ എല്ലാ സന്ദർഭങ്ങളെയും "കൊല്ലുന്നു". ഉദാഹരണത്തിന്, നിങ്ങൾ ഒന്നിലധികം സന്ദർഭങ്ങൾ ഉപയോഗിക്കുകയാണെങ്കിൽ ഫയർഫോക്സ് ബ്രൗസർ, കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് അവരെയെല്ലാം കൊല്ലാൻ കഴിയും:

#ഫയർഫോക്സിനെ കൊല്ലുക

ഗ്നോമിൽ, നിങ്ങൾക്ക് കമാൻഡ് ഉപയോഗിച്ച് നോട്ടിലസ് പുനരാരംഭിക്കാം:

#കില്ലൽനോട്ടിലസ്

xkill

Xkill ആണ് ഗ്രാഫിക്കായിആപ്ലിക്കേഷൻ "കൊല്ലുക". നിങ്ങൾ ടെർമിനലിൽ "XKill" നൽകുമ്പോൾ, മൗസ് കഴ്സർ ഉടൻ തന്നെ ഒരു "ക്രോസ്" ആയി മാറും. നിങ്ങൾ ചെയ്യേണ്ടത് കുറ്റകരമായ ആപ്പിൽ "ക്രോസ്" അമർത്തുക, അത് ആപ്പിനെ തൽക്ഷണം നശിപ്പിക്കും. നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെങ്കിൽ, XKill സവിശേഷത പ്രവർത്തനക്ഷമമാക്കാൻ നിങ്ങൾക്ക് ഒരു കീബോർഡ് കുറുക്കുവഴി ചേർക്കാവുന്നതാണ്.

ഉപയോഗിക്കുന്ന മറ്റ് സിഗ്നലുകൾ

സിഗാബ്ർട്ട്

ഈ സിഗ്നൽ പ്രവർത്തനം നിർത്തലാക്കുന്നതിനുള്ള പ്രക്രിയയിലേക്ക് ഒരു സിഗ്നൽ അയയ്ക്കുന്നു. ABRT സാധാരണഗതിയിൽ C പ്രോഗ്രാമിംഗ് ഭാഷയുടെ abort() ഫംഗ്‌ഷനെ ഒരു അസാധാരണമായ അവസാനിപ്പിക്കൽ സിഗ്നലായി വിളിക്കുമ്പോൾ പ്രക്രിയയിൽ തന്നെ നയിക്കപ്പെടുന്നു, എന്നാൽ മറ്റേതൊരു സിഗ്നലിനെയും പോലെ ഏത് പ്രക്രിയയിൽ നിന്നും ഇത് നയിക്കാനാകും.

SIGALRM, SIGVTALRM, SIGPROF

ALRM, VTALRM കൂടാതെ/അല്ലെങ്കിൽ PROF സിഗ്നൽ ഒരു അലാറം ഫംഗ്‌ഷനിലേക്കുള്ള ഒരു കോൾ (സെറ്റിറ്റിമർ പോലുള്ളവ) കാലഹരണപ്പെടുമ്പോൾ ഒരു പ്രോസസ്സിലേക്ക് അയയ്‌ക്കുന്നു.

ALRM

ഇപ്പോഴത്തെ സമയമോ ക്ലോക്കോ കഴിയുമ്പോൾ അയച്ചു.

VTALRM

ഒരു പ്രോസസ്സ് ഉപയോഗിക്കുന്ന CPU സമയം കാലഹരണപ്പെടുമ്പോൾ അയച്ചു.

പ്രൊഫ

ഒരു പ്രോസസ്സ് ഉപയോഗിക്കുന്ന സിപിയു സമയവും പ്രോസസ്സിന് വേണ്ടിയുള്ള സിസ്റ്റവും കാലഹരണപ്പെടുമ്പോൾ അയച്ചു.

സിഗ്ബസ്

ഒരു ബസ് പിശകിന് കാരണമാകുമ്പോൾ ഒരു പ്രോസസ്സിലേക്ക് ഒരു BUS സിഗ്നൽ അയയ്ക്കുന്നു. മെമ്മറി ആക്‌സസ് തെറ്റായി ക്രമപ്പെടുത്തൽ അല്ലെങ്കിൽ നഷ്‌ടമായ ഫിസിക്കൽ വിലാസം പോലുള്ള ഈ സിഗ്നലിന് കാരണമാകുന്ന അവസ്ഥകൾ.

SIGCHLD

ഒരു ചൈൽഡ് പ്രോസസ്സ് അവസാനിക്കുമ്പോഴോ തടസ്സപ്പെടുമ്പോഴോ അല്ലെങ്കിൽ തടസ്സപ്പെട്ടതിന് ശേഷം പുനരാരംഭിക്കുമ്പോഴോ ഒരു പ്രക്രിയയിലേക്ക് CHLD സിഗ്നൽ അയയ്ക്കുന്നു. ഒരു സിഗ്നലിൻ്റെ ഒരു സാധാരണ ഉപയോഗം, ഒരു ചൈൽഡ് പ്രോസസ്സ് അവസാനിച്ചതിന് ശേഷം, വ്യക്തമായ ഒരു സിസ്റ്റം കോൾ ഇല്ലാതെ അത് ഉപയോഗിക്കുന്ന ഉറവിടങ്ങൾ വൃത്തിയാക്കാൻ OS-നെ സിഗ്നൽ നൽകുക എന്നതാണ്.

SIGCONT

ഒരു STOP അല്ലെങ്കിൽ TSTP സിഗ്നൽ ഉപയോഗിച്ച് മുമ്പ് താൽക്കാലികമായി നിർത്തിവച്ച ഒരു പ്രോസസ്സ് പുനരാരംഭിക്കാൻ CONT സിഗ്നൽ ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തോട് നിർദ്ദേശിക്കുന്നു. അതിലൊന്ന് പ്രധാന സവിശേഷതകൾഈ സിഗ്നൽ യുണിക്സ് ഷെല്ലിലെ ജോലിയുടെ നിയന്ത്രണമാണ്.

SIGFPE

പൂജ്യം കൊണ്ട് ഹരിക്കുന്നത് പോലെയുള്ള തെറ്റായ ഗണിത പ്രവർത്തനങ്ങൾ നടത്തുമ്പോൾ FPE സിഗ്നൽ ഒരു പ്രക്രിയയിലേക്ക് അയയ്ക്കുന്നു.

SIGHUP

നിയന്ത്രണ ടെർമിനൽ അടച്ചിരിക്കുമ്പോൾ HUP സിഗ്നൽ ഒരു പ്രോസസ്സിലേക്ക് അയയ്‌ക്കുന്നു. തുടർച്ചയായ ലൈൻ ഡ്രോപ്പുകൾക്ക് ശേഷം ഒരു പ്രക്രിയയെ അറിയിക്കുന്നതിനാണ് ഇത് യഥാർത്ഥത്തിൽ രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത് (ഹാങ്ങിൻ്റെ ഉത്തരവാദിത്തം HUP). IN ആധുനിക സംവിധാനങ്ങൾ, ഈ സിഗ്നൽ സാധാരണയായി അർത്ഥമാക്കുന്നത് കപട അല്ലെങ്കിൽ വെർച്വൽ ടെർമിനൽ നിയന്ത്രണം അടച്ചു എന്നാണ്.

സിഗിൽ

ക്ഷുദ്രകരമോ അജ്ഞാതമോ പ്രത്യേകാവകാശമുള്ളതോ ആയ കമാൻഡുകൾ (നിർദ്ദേശങ്ങൾ) എക്സിക്യൂട്ട് ചെയ്യാൻ ശ്രമിക്കുമ്പോൾ ഒരു പ്രോസസ്സിലേക്ക് ILL സിഗ്നൽ അയയ്ക്കുന്നു.

SIGINT

ഉപയോക്താവ് പ്രോസസ്സ് അവസാനിപ്പിക്കാൻ ആഗ്രഹിക്കുമ്പോൾ കൺട്രോൾ ടെർമിനലിൽ നിന്ന് ഒരു പ്രോസസ്സിലേക്ക് INT സിഗ്നൽ അയയ്‌ക്കുന്നു. കൺട്രോൾ-സി അമർത്തിയാണ് ഇത് സാധാരണയായി ആരംഭിക്കുന്നത്, എന്നാൽ ചില സിസ്റ്റങ്ങളിൽ, "ഡിലീറ്റ്" അല്ലെങ്കിൽ "ബ്രേക്ക്".

SIGKILL

KILL സിഗ്നൽ ഉടൻ പ്രവർത്തിക്കുന്നത് നിർത്തുന്നതിനുള്ള ഒരു പ്രക്രിയയിലേക്ക് അയച്ചു. SIGTERM, SIGINT എന്നിവയിൽ നിന്ന് വ്യത്യസ്തമായി, ഈ സിഗ്നൽ ക്യാപ്‌ചർ ചെയ്യാനോ അവഗണിക്കാനോ കഴിയില്ല, കൂടാതെ ഈ സിഗ്നൽ ലഭിച്ചതിന് ശേഷം സ്വീകരിക്കുന്ന പ്രക്രിയയ്ക്ക് ഒരു ക്ലീനപ്പും നടത്താൻ കഴിയില്ല.

സിഗ്പൈപ്പ്

PIPE സിഗ്നൽ ഒരു പ്രോസസ്സിലേക്ക് അയയ്‌ക്കുന്നത് മറ്റേ അറ്റവുമായി ബന്ധിപ്പിച്ചിരിക്കുന്ന ഒരു പ്രക്രിയ കൂടാതെ ഒരു പൈപ്പിലേക്ക് എഴുതാൻ ശ്രമിക്കുമ്പോൾ.

SIGQUIT

ഒരു ഡംപ് നടത്താൻ ഉപയോക്താവ് പ്രോസസ്സ് അഭ്യർത്ഥിക്കുമ്പോൾ അതിൻ്റെ കൺട്രോളിംഗ് ടെർമിനലിൽ നിന്ന് ഒരു പ്രോസസ്സിലേക്ക് QUIT സിഗ്നൽ അയയ്‌ക്കുന്നു.

SIGSEGV

SEGV സിഗ്നൽ ഒരു അസാധുവായ വെർച്വൽ മെമ്മറി റഫറൻസ് അല്ലെങ്കിൽ സെഗ്മെൻ്റേഷൻ തകരാർ ഉണ്ടാക്കുമ്പോൾ, അതായത്, ഒരു സെഗ്മെൻ്റേഷൻ ലംഘനം നടത്തുമ്പോൾ, ഒരു പ്രോസസ്സിലേക്ക് അയയ്ക്കുന്നു.

SIGSTOP

STOP സിഗ്നൽ പ്രക്രിയ നിർത്താൻ OS-നോട് പറയുന്നു, അതിനാൽ അത് പിന്നീട് പുനരാരംഭിക്കാനാകും.

SIGTERM

TERM സിഗ്നൽ അവസാനിപ്പിക്കാൻ അഭ്യർത്ഥിക്കുന്നതിന് ഒരു പ്രക്രിയയിലേക്ക് അയയ്‌ക്കുന്നു. "കൊല്ലുക" സിഗ്നലിൽ നിന്ന് വ്യത്യസ്തമായി, പ്രോസസ്സ് സമയത്ത് ഇത് വ്യാഖ്യാനിക്കുകയോ അവഗണിക്കുകയോ ചെയ്യാം. റിസോഴ്‌സുകൾ റിലീസ് ചെയ്യുന്നത് നിർത്താനും ആവശ്യമെങ്കിൽ സ്റ്റേറ്റ് സംരക്ഷിക്കാനും "നല്ല" എക്‌സിക്യൂഷൻ നടത്താൻ ഇത് പ്രക്രിയയെ അനുവദിക്കുന്നു. SIGINT ഏതാണ്ട് SIGTERM ന് സമാനമാണ് എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്.

SIGTSTP

TSTP സിഗ്നൽ അതിൻ്റെ കൺട്രോൾ ടെർമിനൽ പ്രോസസിലേക്ക് അയയ്ക്കുകയും താൽക്കാലികമായി താൽക്കാലികമായി നിർത്താൻ പറയുകയും ചെയ്യുന്നു. ഇത് സാധാരണയായി കൺട്രോൾ-ഇസഡ് അമർത്തുന്നത് വഴിയാണ് ആരംഭിക്കുന്നത്. SIGSTOP പോലെയല്ല, ഈ പ്രക്രിയയ്ക്ക് ഒരു സിഗ്നൽ ഹാൻഡ്‌ലർ രജിസ്റ്റർ ചെയ്യാനോ സിഗ്നൽ അവഗണിക്കാനോ കഴിയും.

SIGTTIN, SIGTTOU

പശ്ചാത്തലത്തിലുള്ള ഒരു (tty) ടെർമിനലിൽ നിന്ന് യഥാക്രമം വായിക്കാനോ എഴുതാനോ ശ്രമിക്കുമ്പോൾ TTIN, TTOU സിഗ്നലുകൾ ഒരു പ്രോസസ്സിലേക്ക് അയയ്‌ക്കുന്നു. ചട്ടം പോലെ, നിയന്ത്രണത്തിലുള്ള പ്രക്രിയകൾ ഉപയോഗിച്ച് മാത്രമേ ഈ സിഗ്നൽ ലഭിക്കൂ പ്രവർത്തന പാനൽ; ഡെമണുകൾക്ക് നിയന്ത്രണ ടെർമിനലുകൾ ഇല്ല, ഈ സിഗ്നൽ ഒരിക്കലും ലഭിക്കരുത്.

SIGUSR1, SIGUSR2

USR1, USR2 എന്നീ സിഗ്നലുകൾ പ്രോസസ്സിലേക്ക് അയയ്ക്കുകയും സൂചിപ്പിക്കുകയും ചെയ്യുന്നു ഉപയോക്താവ് നിർവചിച്ചുവ്യവസ്ഥകൾ.

SIGPOLL

ഒരു അസിൻക്രണസ് I/O ഇവൻ്റ് സംഭവിക്കുമ്പോൾ POLL സിഗ്നൽ ഒരു പ്രോസസ്സിലേക്ക് അയയ്‌ക്കുന്നു.

SIGSYS

ഒരു സിസ്റ്റം കോളിലേക്ക് ഒരു മോശം ആർഗ്യുമെൻ്റ് കൈമാറുമ്പോൾ SYS സിഗ്നൽ ഒരു പ്രോസസ്സിലേക്ക് അയയ്ക്കുന്നു.

സിഗ്ട്രാപ്പ്

ഡീബഗ്ഗർ അറിയിക്കാൻ ആവശ്യപ്പെടുന്ന ഒരു അവസ്ഥ ഉണ്ടാകുമ്പോൾ ഒരു പ്രോസസ്സിലേക്ക് ഒരു TRAP സിഗ്നൽ അയയ്‌ക്കുന്നു-ഉദാഹരണത്തിന്, ഒരു പ്രത്യേക ഫംഗ്‌ഷൻ എക്‌സിക്യൂട്ട് ചെയ്യുമ്പോൾ അല്ലെങ്കിൽ ഒരു വേരിയബിളിൻ്റെ ഒരു പ്രത്യേക മൂല്യം മാറുമ്പോൾ.

സിഗുർഗ്

സോക്കറ്റിൽ വായിക്കാൻ ആവശ്യമായ അല്ലെങ്കിൽ പരിധിക്ക് പുറത്തുള്ള ഡാറ്റ ലഭ്യമാകുമ്പോൾ URG സിഗ്നൽ ഒരു പ്രോസസ്സിലേക്ക് അയയ്‌ക്കുന്നു.

SIGXCPU

ഒരു നിശ്ചിത സമയത്തിൽ കൂടുതൽ CPU ഉപയോഗിക്കുമ്പോൾ ഒരു പ്രോസസ്സിലേക്ക് ഒരു XCPU സിഗ്നൽ അയയ്‌ക്കുന്നു സെറ്റ് മൂല്യം, ഉപയോക്താവ് ഇൻസ്റ്റാൾ ചെയ്തു. XCPU സിഗ്നലിൻ്റെ വരവ് എല്ലാം വേഗത്തിൽ സംരക്ഷിക്കാൻ പ്രക്രിയയെ അനുവദിക്കുന്നു ഇൻ്റർമീഡിയറ്റ് ഫലങ്ങൾകൂടാതെ SIGKILL സിഗ്നൽ ഉപയോഗിച്ച് ഓപ്പറേറ്റിംഗ് സിസ്റ്റം കൊല്ലപ്പെടുന്നതിന് മുമ്പ് അത് പുറത്തുകടക്കുന്നു.

SIGXFSZ

അനുവദനീയമായ പരമാവധി മൂല്യത്തേക്കാൾ ഒരു ഫയൽ വലുതാകുമ്പോൾ (നിർദ്ദിഷ്‌ട മൂല്യം കവിയുന്നു) പ്രക്രിയയിൽ XFSZ സിഗ്നൽ അയയ്ക്കുന്നു.

SIGRTMIN SIGRTMAX-ലേക്ക്

RTMIN - RTMAX സിഗ്നലുകൾ ഇഷ്‌ടാനുസൃത ആവശ്യങ്ങൾക്കായി ഉപയോഗിക്കാൻ ഉദ്ദേശിച്ചുള്ളതാണ്. അവ തത്സമയ സിഗ്നലുകളാണ്.

വ്യത്യസ്ത സിഗ്നലുകൾ

ഇനിപ്പറയുന്ന സിഗ്നലുകൾ POSIX മുഖേന സ്റ്റാൻഡേർഡ് ചെയ്തിട്ടില്ല, എന്നാൽ ചിലപ്പോൾ ചില സിസ്റ്റങ്ങളിൽ ഉപയോഗിക്കാറുണ്ട്.

SIGEMT

ഒരു എമുലേറ്റർ തടസ്സം സംഭവിക്കുമ്പോൾ EMT സിഗ്നൽ അയയ്‌ക്കപ്പെടുന്നു.

SIGINFO

കൺട്രോൾ ടെർമിനലിൽ നിന്ന് ഒരു സ്റ്റാറ്റസ് അഭ്യർത്ഥന ലഭിക്കുമ്പോൾ INFO സിഗ്നൽ പുരോഗമിക്കുന്നു.

SIGPWR

സിസ്റ്റത്തിന് വൈദ്യുതി തകരാർ അനുഭവപ്പെടുമ്പോൾ PWR സിഗ്നൽ അയയ്‌ക്കുന്നു.

സിഗ്ലോസ്റ്റ്

ഒരു "ഫയൽ ലോക്ക്" നഷ്‌ടപ്പെടുമ്പോൾ നഷ്‌ടമായ സിഗ്നൽ ഒരു പ്രോസസ്സിലേക്ക് അയയ്‌ക്കുന്നു.

സിഗ്വിഞ്ച്

കൺട്രോൾ ടെർമിനൽ അതിൻ്റെ വലുപ്പം മാറ്റുമ്പോൾ WINCH സിഗ്നൽ ഒരു പ്രോസസ്സിലേക്ക് അയയ്ക്കുന്നു.

കീബോർഡിൽ നിന്ന് സിഗ്നലുകൾ അയയ്ക്കുന്നു

കീബോർഡിൽ നിന്ന് സിഗ്നലുകൾ അയയ്ക്കാം. നിരവധി സ്റ്റാൻഡേർഡ് ഡിഫോൾട്ട് മൂല്യങ്ങൾ ചുവടെ പട്ടികപ്പെടുത്തിയിരിക്കുന്നു. ഡിഫോൾട്ടായി, ഇൻ്ററപ്റ്റ് സിഗ്നലുകൾ അയയ്ക്കുന്നതിനുള്ള കീബോർഡ് കുറുക്കുവഴികൾ stty കമാൻഡ് ഉപയോഗിച്ച് നിർവചിക്കാം.

CTRL-C

SIGINT അയയ്‌ക്കുക (തടസ്സം). സ്ഥിരസ്ഥിതിയായി ഇത് പ്രക്രിയ അവസാനിപ്പിക്കുന്നതിന് കാരണമാകുന്നു.

CTRL-Z

SIGTSTP അയയ്‌ക്കുക (സസ്പെൻഡ്). സ്ഥിരസ്ഥിതിയായി, ഇത് എല്ലാ പ്രവർത്തനങ്ങളും താൽക്കാലികമായി നിർത്തിവയ്ക്കുന്നതിന് കാരണമാകുന്നു.

CTRL-\

SIGQUIT അയയ്‌ക്കുക (പുറത്തുകടക്കുക). സ്വതവേ, ഇത് പ്രക്രിയ ഉടനടി അവസാനിപ്പിക്കുന്നതിനും കേർണൽ പുനഃസജ്ജമാക്കുന്നതിനും കാരണമാകുന്നു.

CTRL-T

SIGINFO (INFO) അയയ്‌ക്കുക. സ്ഥിരസ്ഥിതിയായി, ഇത് കമാൻഡിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ പ്രദർശിപ്പിക്കുന്നതിന് ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിന് കാരണമാകുന്നു. എല്ലാ സിസ്റ്റങ്ങളിലും പിന്തുണയ്ക്കുന്നില്ല.

ഉപസംഹാരം

ആപ്ലിക്കേഷനുകൾ തെറ്റായി പ്രവർത്തിക്കുകയും സിസ്റ്റം മരവിപ്പിക്കുകയും ചെയ്യുമ്പോൾ, നിങ്ങളുടെ കമ്പ്യൂട്ടർ പുനരാരംഭിച്ച് സെഷൻ വീണ്ടും ആരംഭിക്കുന്നത് വളരെ പ്രലോഭനമാണ്. ഈ "കിൽ" കമാൻഡുകൾ ഉപയോഗിച്ച്, ഒരു സിസ്റ്റം ക്രാഷിന് കാരണമാകുന്ന അല്ലെങ്കിൽ കാരണമായേക്കാവുന്ന ആപ്ലിക്കേഷനുകളുടെ മോശം പെരുമാറ്റം നിങ്ങൾക്ക് നന്നായി കൈകാര്യം ചെയ്യാൻ കഴിയും. ഇതോടെ ഞാൻ ഉപസംഹരിക്കുന്നു ഈ വിഷയം"Unix/Linux-ലെ കിൽ കമാൻഡ്."

ഇനി നമുക്ക് മറ്റൊരു പ്രോഗ്രാം പരിഗണിക്കാം - 13–14-3.c:

/* ഇഷ്‌ടാനുസൃത SIGINT സിഗ്നൽ പ്രോസസ്സിംഗ് ഉള്ള പ്രോഗ്രാം */ #ഉൾപ്പെടുന്നു #ഉൾപ്പെടുന്നു /* ഫംഗ്ഷൻ my_handler ഒരു ഇഷ്‌ടാനുസൃത സിഗ്നൽ ഹാൻഡ്‌ലറാണ് */ void my_handler(int nsig)( printf("സിഗ്നൽ സ്വീകരിക്കുക %d, CTRL-C അമർത്തി\n", nsig); ) int main(void)( /* പ്രോസസ്സ് പ്രതികരണം സജ്ജമാക്കുക സിഗ്നലിലേക്ക് SIGINT */ (void) സിഗ്നലിലേക്ക് (SIGINT, my_handler); /*ഈ പോയിൻ്റ് മുതൽ, പ്രക്രിയ SIGINT സിഗ്നൽ സംഭവിക്കുന്നതിനെക്കുറിച്ചുള്ള ഒരു സന്ദേശം പ്രിൻ്റ് ചെയ്യും */ while(1); 0; തിരികെ നൽകുക ലിസ്റ്റിംഗ് 13-14.3. SIGINT സിഗ്നലിൻ്റെ ഇഷ്‌ടാനുസൃത പ്രോസസ്സിംഗ് ഉള്ള പ്രോഗ്രാം (13–14-3.c).

ഈ പ്രോഗ്രാം "ഒരു സിഗ്നൽ അവഗണിക്കുന്ന ഒരു പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുക" എന്ന വിഭാഗത്തിലെ പ്രോഗ്രാമിൽ നിന്ന് വ്യത്യസ്തമാണ്. SIGINT"കാരണം ഇത് സിഗ്നൽ പ്രോസസ്സിംഗ് അവതരിപ്പിക്കുന്നു SIGINTഇച്ഛാനുസൃത പ്രവർത്തനം. ഈ പ്രോഗ്രാം ടൈപ്പ് ചെയ്യുക, കംപൈൽ ചെയ്യുക, പ്രവർത്തിപ്പിക്കുക, കീ അമർത്തലുകളോടുള്ള അതിൻ്റെ പ്രതികരണം പരിശോധിക്കുക< CTRL >ഒപ്പം കീസ്‌ട്രോക്കുകളിലും< CTRL >ഒപ്പം<4>.

SIGINT, SIGQUIT സിഗ്നലുകളുടെ ഇഷ്‌ടാനുസൃത പ്രോസസ്സിംഗിനായി മുമ്പത്തെ പ്രോഗ്രാമിൻ്റെ പരിഷ്‌ക്കരണം

മുമ്പത്തെ വിഭാഗത്തിൽ നിന്ന് പ്രോഗ്രാം പരിഷ്‌ക്കരിക്കുക, അതുവഴി കീപ്രസ്സുകളെക്കുറിച്ചുള്ള ഒരു സന്ദേശം അത് പ്രിൻ്റ് ചെയ്യുന്നു.< CTRL >ഒപ്പം<4>. സിഗ്നൽ പ്രോസസ്സിംഗിനും ഇതേ പ്രവർത്തനം ഉപയോഗിക്കുക SIGINTഒപ്പം SIGQUIT. ഇത് കംപൈൽ ചെയ്ത് പ്രവർത്തിപ്പിക്കുക, ഇത് ശരിയായി പ്രവർത്തിക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കുക. കമാൻഡ് ഉപയോഗിച്ച് മറ്റൊരു ടെർമിനലിൽ നിന്നും പ്രോഗ്രാം നീക്കം ചെയ്യേണ്ടിവരും കൊല്ലുക.

ഒരു സിഗ്നലിലേക്കുള്ള മുൻ പ്രതികരണം പുനഃസ്ഥാപിക്കുന്നു

ഇതുവരെയുള്ള ഉദാഹരണങ്ങളിൽ, സിസ്റ്റം കോൾ നൽകുന്ന മൂല്യം ഞങ്ങൾ അവഗണിച്ചു സിഗ്നൽ(). ഈ സിസ്റ്റം കോൾ യഥാർത്ഥത്തിൽ മുമ്പത്തെ സിഗ്നൽ ഹാൻഡ്‌ലറിലേക്ക് ഒരു പോയിൻ്റർ നൽകുന്നു, ഇത് സിഗ്നലിലേക്കുള്ള അസാധുവായ പ്രതികരണം പുനഃസ്ഥാപിക്കാൻ അനുവദിക്കുന്നു. 13-14-4.c പ്രോഗ്രാമിൻ്റെ ഉദാഹരണം പരിഗണിക്കുക, ഇത് ഒരു സിഗ്നലിലേക്കുള്ള പ്രാരംഭ പ്രതികരണം നൽകുന്നു SIGINT 5 ഇഷ്‌ടാനുസൃത സിഗ്നൽ പ്രോസസ്സിംഗിന് ശേഷം.

/* SIGINT സിഗ്നലിൻ്റെ ഇഷ്‌ടാനുസൃത പ്രോസസ്സിംഗ് ഉള്ള ഒരു പ്രോഗ്രാം, അതിൻ്റെ 5 പ്രോസസ്സിംഗിന് ശേഷം ഈ സിഗ്നലിലേക്കുള്ള യഥാർത്ഥ പ്രതികരണത്തിലേക്ക് മടങ്ങുന്നു */ #include #ഉൾപ്പെടുന്നു int i=0; /* സിഗ്നൽ പ്രോസസ്സിംഗിൻ്റെ എണ്ണത്തിൻ്റെ കൗണ്ടർ */ ശൂന്യമായ (*p)(int); /* മുൻ സിഗ്നൽ ഹാൻഡ്‌ലറിൻ്റെ വിലാസം നൽകേണ്ട പോയിൻ്റർ */ nsig); i = i+1; /* അഞ്ചാമത്തെ പ്രോസസ്സിംഗിന് ശേഷം, ഞങ്ങൾ സിഗ്നലിലേക്ക് പ്രാരംഭ പ്രതികരണം നൽകുന്നു */ if(i == 5) (void)signal(SIGINT, p); ) int main(void)( /* മുമ്പത്തെ ഹാൻഡ്‌ലറിൻ്റെ വിലാസം ഓർമ്മിച്ചുകൊണ്ട് ഞങ്ങൾ SIGINT സിഗ്നലിലേക്ക് ഞങ്ങളുടെ പ്രോസസ്സ് പ്രതികരണം സജ്ജമാക്കി */ p = സിഗ്നലിൻ്റെ (SIGINT, my_handler); /* ഈ പോയിൻ്റ് മുതൽ, SIGINT സിഗ്നലിൻ്റെ സംഭവത്തെക്കുറിച്ചുള്ള ഒരു സന്ദേശം പ്രോസസ്സ് പ്രിൻ്റ് ചെയ്യും. 5 തവണ */ സമയത്ത്(1); തിരികെ 0;) ലിസ്റ്റിംഗ് 13-14.4. SIGINT സിഗ്നലിൻ്റെ ഇഷ്‌ടാനുസൃത പ്രോസസ്സിംഗ് ഉള്ള പ്രോഗ്രാം (13-14-4.c).

ടൈപ്പ് ചെയ്യുക, പ്രോഗ്രാം കംപൈൽ ചെയ്ത് പ്രവർത്തിപ്പിക്കുക.

സിഗ്നലുകൾ SIGUSR1, SIGUSR2. പ്രക്രിയകൾ സമന്വയിപ്പിക്കാൻ സിഗ്നലുകൾ ഉപയോഗിക്കുന്നു

UNIX ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൽ, രണ്ട് സിഗ്നലുകൾ ഉണ്ട്, അവയുടെ ഉറവിടങ്ങൾ ഒരു സിസ്റ്റം കോൾ മാത്രമായിരിക്കും കൊല്ലുക()അല്ലെങ്കിൽ കമാൻഡ് കൊല്ലുക, സിഗ്നലുകളാണ് SIGUSR1ഒപ്പം SIGUSR2. ഒരു ഉപയോക്തൃ പ്രക്രിയയിൽ നിന്ന് മറ്റൊന്നിലേക്ക് സംഭവിച്ച ഒരു സംഭവത്തെക്കുറിച്ചുള്ള വിവരങ്ങൾ കൈമാറാൻ അവ സാധാരണയായി ഉപയോഗിക്കുന്നു ആശയവിനിമയത്തിനുള്ള സിഗ്നലിംഗ് മാർഗങ്ങൾ.

സെമിനാർ 5 ൻ്റെ മെറ്റീരിയലുകളിൽ ("പൈപ്പിലൂടെ ബന്ധപ്പെട്ട പ്രക്രിയകൾക്കിടയിൽ ദ്വിദിശ ആശയവിനിമയം സംഘടിപ്പിക്കുന്നതിനുള്ള ഒരു പ്രോഗ്രാം എഴുതുക, സമാഹരിക്കുക, പ്രവർത്തിപ്പിക്കുക"), പൈപ്പിലൂടെയുള്ള അനുബന്ധ പ്രക്രിയകളുടെ ആശയവിനിമയം പരിഗണിച്ചപ്പോൾ, പൈപ്പ് ഒരു ഏകദിശ ആശയവിനിമയ ചാനലാണെന്ന് പറഞ്ഞു. രണ്ട് ദിശകളിലേക്ക് ഒരു പൈപ്പിലൂടെ ആശയവിനിമയം സംഘടിപ്പിക്കുന്നതിന്, പ്രക്രിയകളുടെ പരസ്പര സമന്വയത്തിനുള്ള സംവിധാനങ്ങൾ ഉപയോഗിക്കേണ്ടത് ആവശ്യമാണ്. സമന്വയത്തിനായി സിഗ്നലുകൾ ഉപയോഗിച്ച് ഒരു പൈപ്പ് വഴി ഒരു പാരൻ്റ് പ്രോസസും ചൈൽഡ് പ്രോസസും തമ്മിൽ രണ്ട്-വഴി ഇതര ആശയവിനിമയം സംഘടിപ്പിക്കുക SIGUSR1ഒപ്പം SIGUSR2വിഭാഗത്തിൽ നിന്ന് പ്രോഗ്രാം പരിഷ്ക്കരിച്ചുകൊണ്ട്. "പൈപ്പ് വഴി ബന്ധപ്പെട്ട പ്രക്രിയകൾക്കിടയിൽ ഏകപക്ഷീയമായ ആശയവിനിമയം സംഘടിപ്പിക്കുന്നതിനുള്ള ഒരു പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നു" സെമിനാർ 5.

വിപുലമായ ചുമതല: സിഗ്നലുകൾ മാത്രം ഉപയോഗിച്ച് രണ്ട് പ്രക്രിയകൾക്കിടയിൽ ഒരു പൂർണ്ണസംഖ്യ ബിറ്റ്വൈസ് കൈമാറുക SIGUSR1ഒപ്പം SIGUSR2.

ഓപ്പറേറ്റിംഗ് റൂമിൽ എക്സിക്യൂഷൻ ത്രെഡുകൾ നടപ്പിലാക്കുമ്പോൾ ലിനക്സ് സിസ്റ്റം("UNIX-ലെ ത്രെഡ് മനസ്സിലാക്കൽ" എന്ന വിഭാഗത്തിൽ തുടങ്ങുന്ന വർക്ക്ഷോപ്പുകൾ 6-7 കാണുക. എക്സിക്യൂഷൻ ത്രെഡ് ഐഡി. ഫംഗ്ഷൻ pthread_self() ") സിഗ്നലുകൾ SIGUSR1ഒപ്പം SIGUSR2എക്സിക്യൂഷൻ ത്രെഡുകളെ പ്രതിനിധീകരിക്കുന്ന പ്രക്രിയകളും ഔദ്യോഗിക ആവശ്യങ്ങൾക്കായി ഏകോപിപ്പിക്കുന്ന പ്രക്രിയയും തമ്മിലുള്ള സമന്വയം സംഘടിപ്പിക്കാൻ ഉപയോഗിക്കുന്നു. അതിനാൽ, അവരുടെ ജോലിയിൽ എക്സിക്യൂഷൻ ത്രെഡുകൾ ഉപയോഗിക്കുന്ന ഉപയോക്തൃ പ്രോഗ്രാമുകൾ ഉപയോഗിക്കാൻ കഴിയില്ലസിഗ്നലുകൾ SIGUSR1ഒപ്പം SIGUSR2.

മുട്ടയിടുന്ന പ്രക്രിയയുടെ അവസാനിപ്പിക്കൽ. Waitpid() സിസ്റ്റം കോൾ. സിഗ്നൽ SIGCHLD

സെമിനാറുകളുടെ മെറ്റീരിയലുകളിൽ 3-4 (വിഭാഗം " പ്രക്രിയ അവസാനിപ്പിക്കുന്നു. എക്സിറ്റ്() ഫംഗ്‌ഷൻ ") പ്രക്രിയ അവസാനിപ്പിക്കൽ പഠിക്കുമ്പോൾ, ഒരു ചൈൽഡ് പ്രോസസ്സ് അതിൻ്റെ പാരൻ്റ് പ്രോസസിന് മുമ്പ് പുറത്തുകടക്കുകയാണെങ്കിൽ, അതിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ നേടുന്നതിൽ താൽപ്പര്യമില്ലെന്ന് രക്ഷാകർതൃ പ്രക്രിയ വ്യക്തമായി സൂചിപ്പിച്ചിട്ടില്ല. പൂർത്തീകരണ നിലചൈൽഡ് പ്രോസസ്സ്, തുടർന്ന് പൂർത്തിയാക്കിയ പ്രക്രിയ സിസ്റ്റത്തിൽ നിന്ന് പൂർണ്ണമായും അപ്രത്യക്ഷമാകില്ല, പക്ഷേ സംസ്ഥാനത്ത് തുടരുന്നു പ്രകടനം പൂർത്തിയാക്കി(സോംബി പ്രോസസ്സ്) ഒന്നുകിൽ രക്ഷാകർതൃ പ്രക്രിയ അവസാനിക്കുന്നത് വരെ, അല്ലെങ്കിൽ രക്ഷിതാവ് ഈ വിവരങ്ങൾ സ്വീകരിക്കാൻ തയ്യാറാകുന്നത് വരെ.

അത്തരം വിവരങ്ങൾ ലഭിക്കുന്നതിന്, പാരൻ്റ് പ്രോസസ്സിന് സിസ്റ്റം കോൾ ഉപയോഗിക്കാം വെയിറ്റ്പിഡ്()അല്ലെങ്കിൽ അതിൻ്റെ ലളിതമായ രൂപം കാത്തിരിക്കുക(). സിസ്റ്റം കോൾ വെയിറ്റ്പിഡ്()ചൈൽഡ് പ്രോസസ്സ് അവസാനിക്കുന്നത് വരെ പാരൻ്റ് പ്രോസസ് തടയുകയോ അല്ലെങ്കിൽ WNOHANG ഓപ്‌ഷൻ ഉപയോഗിച്ച് ആനുകാലികമായി വിളിക്കുമ്പോൾ തടയുകയോ ചെയ്യാതെ, അവസാനിപ്പിച്ച ചൈൽഡ് പ്രോസസിൻ്റെ നിലയെക്കുറിച്ചുള്ള വിവരങ്ങൾ സമന്വയിപ്പിക്കാൻ ഒരു പാരൻ്റ് പ്രോസസിനെ അനുവദിക്കുന്നു. ഈ ഡാറ്റ 16 ബിറ്റുകൾ എടുക്കുന്നു, ഞങ്ങളുടെ കോഴ്സിൽ ഇനിപ്പറയുന്ന രീതിയിൽ ഡീക്രിപ്റ്റ് ചെയ്യാം:

ഓരോ ചൈൽഡ് പ്രോസസ്സും പുറത്തുകടക്കുമ്പോൾ അതിൻ്റെ പാരൻ്റ് പ്രോസസിലേക്ക് ഒരു പ്രത്യേക സിഗ്നൽ അയയ്ക്കുന്നു. SIGCHLD, എല്ലാ പ്രക്രിയകൾക്കും സ്ഥിരസ്ഥിതി പ്രതികരണം "സിഗ്നൽ അവഗണിക്കുക" എന്ന് സജ്ജീകരിച്ചിരിക്കുന്നു. ഒരു സിസ്റ്റം കോളുമായി ചേർന്ന് അത്തരമൊരു സിഗ്നലിൻ്റെ സാന്നിധ്യം വെയിറ്റ്പിഡ്()പാരൻ്റ് പ്രോസസ് പൂർത്തിയാക്കിയ സ്പോൺഡ് പ്രോസസ്സുകളുടെ അവസ്ഥയെക്കുറിച്ചുള്ള വിവരങ്ങളുടെ അസമന്വിത ശേഖരം സംഘടിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

കാത്തിരിക്കുക () ഒപ്പം വെയ്റ്റ്പിഡ് () സിസ്റ്റം കോളുകൾ പ്രോട്ടോടൈപ്പുകൾ സിസ്റ്റം കോളുകൾ #ഉൾപ്പെടുന്നു #ഉൾപ്പെടുന്നു pid_t waitpid(pid_t pid, int *status, int ഓപ്ഷനുകൾ); pid_t കാത്തിരിക്കുക(int *status); സിസ്റ്റം കോളുകളുടെ വിവരണം ഈ വിവരണം സിസ്റ്റം കോളുകളുടെ പൂർണ്ണമായ വിവരണമല്ല, മറിച്ച് ഞങ്ങളുടെ കോഴ്‌സുമായി ബന്ധപ്പെട്ടാണ്. ലഭിക്കുന്നതിന് പൂർണ്ണ വിവരണം UNIX മാനുവൽ കാണുക. സിസ്റ്റം കോൾ വെയിറ്റ്പിഡ്()പിഡ് പാരാമീറ്ററിൻ്റെ മൂല്യം അനുസരിച്ച് നിർണ്ണയിച്ചിരിക്കുന്ന, അല്ലെങ്കിൽ നിലവിലെ പ്രോസസ്സിന് ഡിഫോൾട്ട് "എൻഡ് പ്രോസസ്" പ്രതികരണമോ ഒരു ഇഷ്‌ടാനുസൃത ഫംഗ്ഷൻ കൈകാര്യം ചെയ്യുന്ന പ്രതികരണമോ ഉള്ള ഒരു സിഗ്നൽ ലഭിക്കുന്നത് വരെ, നിലവിലുള്ള പ്രക്രിയയുടെ നിർവ്വഹണത്തെ തടയുന്നു. മുട്ടയിടുന്ന പ്രക്രിയ ആണെങ്കിൽ പരാമീറ്റർ പ്രകാരം വ്യക്തമാക്കിയിരിക്കുന്നുസിസ്റ്റം കോൾ എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ pid പൂർത്തിയായ അവസ്ഥയിലാണ്, നിലവിലെ പ്രക്രിയ തടയാതെ തന്നെ സിസ്റ്റം കോൾ ഉടൻ മടങ്ങിവരും. പിഡ് പാരാമീറ്റർ ഇനിപ്പറയുന്ന രീതിയിൽ പാരൻ്റ് പ്രോസസ്സ് പൂർത്തിയാകാൻ കാത്തിരിക്കുന്ന ചൈൽഡ് പ്രോസസ്സ് വ്യക്തമാക്കുന്നു: pid > 0 ആണെങ്കിൽ, ഐഡൻ്റിഫയർ പിഡ് ഉപയോഗിച്ചുള്ള പ്രക്രിയ അവസാനിപ്പിക്കാൻ കാത്തിരിക്കുക. pid = 0 ആണെങ്കിൽ, പാരൻ്റ് പ്രോസസ് ഉൾപ്പെടുന്ന ഗ്രൂപ്പിലെ ഏതെങ്കിലും ചൈൽഡ് പ്രോസസ് അവസാനിപ്പിക്കുന്നതിനായി ഞങ്ങൾ കാത്തിരിക്കുന്നു. pid = -1 ആണെങ്കിൽ, ഏതെങ്കിലും സ്പോൺഡ് പ്രോസസിൻ്റെ അവസാനത്തിനായി ഞങ്ങൾ കാത്തിരിക്കുന്നു. പിഡ് ആണെങ്കിൽ< 0 , но не –1 , то ожидаем завершения любого порожденного процесса из группы , идентификатор которой равен യഥാർത്ഥ മൂല്യം pid പരാമീറ്റർ. ഞങ്ങളുടെ കോഴ്‌സിലെ ഓപ്ഷനുകൾ പരാമീറ്ററിന് രണ്ട് മൂല്യങ്ങൾ എടുക്കാം: 0, WNOHANG . WNOHANG മൂല്യത്തിന്, ഏത് സാഹചര്യത്തിലും നിലവിലെ പ്രക്രിയ തടയാതെ കോൾ ഉടൻ തന്നെ തിരികെ നൽകേണ്ടതുണ്ട്. പിഡ് പാരാമീറ്റർ വ്യക്തമാക്കിയിട്ടുള്ളവയിൽ നിന്ന് പൂർത്തിയാക്കിയ ചൈൽഡ് പ്രോസസ്സ് സിസ്റ്റം കോൾ കണ്ടെത്തുകയാണെങ്കിൽ, ഈ പ്രക്രിയ കമ്പ്യൂട്ടർ സിസ്റ്റത്തിൽ നിന്ന് നീക്കംചെയ്യപ്പെടും, കൂടാതെ സ്റ്റാറ്റസ് പാരാമീറ്ററിൽ വ്യക്തമാക്കിയ വിലാസത്തിൽ അതിൻ്റെ അവസാനിപ്പിക്കൽ നിലയെക്കുറിച്ചുള്ള വിവരങ്ങൾ സംഭരിക്കും. ഈ വിവരം ഞങ്ങൾക്ക് അർഥവത്തല്ലെങ്കിൽ സ്റ്റാറ്റസ് പാരാമീറ്റർ NULL ആയി സജ്ജീകരിക്കാം. ഒരു അവസാനിപ്പിച്ച പ്രോസസ്സ് കണ്ടെത്തുമ്പോൾ, സിസ്റ്റം കോൾ അതിൻ്റെ ഐഡി നൽകുന്നു. കൂടെ വിളിച്ചിരുന്നെങ്കിൽ ഇൻസ്റ്റാൾ ചെയ്ത ഓപ്ഷൻ WNOHANG ഉം pid വ്യക്തമാക്കിയ സ്പോൺഡ് പ്രോസസ്സും നിലവിലുണ്ട് എന്നാൽ ഇതുവരെ പുറത്തുകടന്നിട്ടില്ല, സിസ്റ്റം കോൾ 0 തിരികെ നൽകും. മറ്റെല്ലാ സാഹചര്യങ്ങളിലും ഇത് നെഗറ്റീവ് മൂല്യം നൽകുന്നു. ഉപയോക്തൃ-പ്രോസസ്സ് ചെയ്ത സിഗ്നലിൻ്റെ സംഭവവുമായി ബന്ധപ്പെട്ട കോളിൽ നിന്നുള്ള ഒരു റിട്ടേൺ സിസ്റ്റം വേരിയബിളായ errno == EINTR ൻ്റെ മൂല്യം ഉപയോഗിച്ച് തിരിച്ചറിയാൻ കഴിയും, കൂടാതെ കോൾ വീണ്ടും വിളിക്കാനും കഴിയും. pid = -1, ഓപ്ഷനുകൾ = 0 എന്നീ പാരാമീറ്റർ മൂല്യങ്ങളുള്ള വെയ്റ്റ്പിഡ് സിസ്റ്റം കോളിൻ്റെ പര്യായമാണ് വെയിറ്റ് സിസ്റ്റം കോൾ. സൃഷ്ടിച്ച പ്രക്രിയ. /* പൂർത്തിയാക്കിയ രണ്ട് ചൈൽഡ് പ്രോസസ്സുകളുടെ അവസ്ഥയെക്കുറിച്ചുള്ള വിവരങ്ങളുടെ അസമന്വിത രസീതോടുകൂടിയ പ്രോഗ്രാം */ #ഉൾപ്പെടുത്തുക #ഉൾപ്പെടുന്നു #ഉൾപ്പെടുന്നു #ഉൾപ്പെടുന്നു #ഉൾപ്പെടുന്നു /* ഫംഗ്ഷൻ my_handler SIGCHLD സിഗ്നലിനുള്ള ഒരു ഹാൻഡ്‌ലറാണ് */ അസാധുവായ my_handler(int nsig)( int status; pid_t pid; /* ഞങ്ങൾ പൂർത്തിയാക്കിയ പ്രക്രിയയുടെ സ്റ്റാറ്റസ് പോൾ ചെയ്യുകയും അതേ സമയം അതിൻ്റെ ഐഡൻ്റിഫയർ കണ്ടെത്തുകയും ചെയ്യുന്നു */ if(( pid = waitpid(-1, &status, 0) )< 0){ /* Если возникла ошибка – сообщаем о ней и продолжаем работу */ printf("Some error on waitpid errno = %d\n", errno); } else { /* Иначе анализируем статус завершившегося процесса */ if ((status & 0xff) == 0) { /* Процесс завершился с явным или неявным вызовом функции exit() */ printf("Process %d was exited with status %d\n", pid, status >> 8); ) അല്ലാത്തപക്ഷം ((സ്റ്റാറ്റസ് & 0xff00) == 0)( /* സിഗ്നൽ */ printf("പ്രോസസ് %d എന്ന സിഗ്നൽ %d %s\n", pid, status &0x7f,(status & 0x80 ) ? "കോർ ഫയലിനൊപ്പം" : "കോർ ഫയൽ ഇല്ലാതെ"); ) ) int main(void)( pid_t pid; /* SIGCHLD സിഗ്നലിനായി ഒരു ഹാൻഡ്‌ലർ സജ്ജീകരിക്കുക */ (ശൂന്യം) സിഗ്നലിനായി (SIGCHLD, my_handler); / * Сhild 1 */ if((pid = fork()) സൃഷ്‌ടിക്കുക< 0){ printf("Can\"t fork child 1\n"); exit(1); } else if (pid == 0){ /* Child 1 – завершается с кодом 200 */ exit(200); } /* Продолжение процесса-родителя – порождаем Сhild 2 */ if((pid = fork()) < 0){ printf("Can\"t fork child 2\n"); exit(1); } else if (pid == 0){ /* Child 2 – циклится, необходимо удалять с помощью сигнала! */ while(1); } /* Продолжение процесса-родителя – уходим в цикл */ while(1); return 0; } ലിസ്റ്റിംഗ് 13-14.5. പൂർത്തിയാക്കിയ രണ്ട് ചൈൽഡ് പ്രോസസുകളുടെ അവസ്ഥയെക്കുറിച്ചുള്ള വിവരങ്ങളുടെ അസമന്വിത രസീതോടുകൂടിയ പ്രോഗ്രാം (13-14-5.c). കൊല്ലുകഏതെങ്കിലും സിഗ്നൽ നമ്പർ ഉപയോഗിച്ച്. രക്ഷാകർതൃ പ്രക്രിയകമാൻഡ് ഉപയോഗിച്ച് അവസാനിപ്പിക്കേണ്ടതും ആവശ്യമാണ് കൊല്ലുക.

ഒരു സിഗ്നൽ അല്ലെങ്കിൽ വെർച്വൽ തടസ്സം എന്നത് സിസ്റ്റം ഒരു പ്രോസസ്സിലേക്ക് അയയ്ക്കുന്ന അല്ലെങ്കിൽ ഒരു പ്രോസസ്സ് മറ്റൊന്നിലേക്ക് അയയ്ക്കുന്ന ഒരു സന്ദേശമാണ്. ഒരു പ്രോസസ്സിന് ഒരു സിഗ്നൽ ലഭിക്കുമ്പോൾ, പ്രോസസ്സ് പ്രോഗ്രാമിൻ്റെ നിർവ്വഹണം തടസ്സപ്പെടുകയും നിയന്ത്രണം സിഗ്നൽ ഹാൻഡ്ലർ സബ്റൂട്ടീനിലേക്ക് (ഫംഗ്ഷൻ) കൈമാറുകയും ചെയ്യുന്നു. സിഗ്നൽ ഹാൻഡ്‌ലർ എക്‌സിക്യൂട്ട് ചെയ്‌ത ശേഷം, തടസ്സപ്പെട്ട പ്രോഗ്രാമിൻ്റെ എക്‌സിക്യൂഷൻ അത് തടസ്സപ്പെട്ട പോയിൻ്റിൽ നിന്ന് പുനരാരംഭിക്കുന്നു.

ഓപ്പറേറ്റിംഗ് സിസ്റ്റം നൽകുന്നു വലിയ സംഖ്യസിഗ്നലുകളുടെ തരങ്ങൾ, എന്നാൽ ഈ തരങ്ങളിൽ ഭൂരിഭാഗവും സിസ്റ്റം ആവശ്യങ്ങൾക്കായി നീക്കിവച്ചിരിക്കുന്നു - ഇവ ഓപ്പറേറ്റിംഗ് സിസ്റ്റം ഒരു പ്രോസസ്സിലേക്ക് അയയ്ക്കുന്ന സിഗ്നലുകളാണ്. എന്നിരുന്നാലും, പ്രക്രിയകൾക്ക് പരസ്പരം കൈമാറ്റം ചെയ്യാൻ കഴിയുന്ന സിഗ്നലുകളും ഉണ്ട്.

മിക്ക സിഗ്നലുകൾക്കുമുള്ള ഡിഫോൾട്ട് പ്രതികരണം, സിഗ്നൽ ലഭിച്ച പ്രക്രിയ അവസാനിപ്പിക്കുക എന്നതാണ്, അതായത്, ഒരു പ്രോസസ്സിന് അത് കൈകാര്യം ചെയ്യാൻ രൂപകൽപ്പന ചെയ്തിട്ടില്ലാത്ത ഒരു സിഗ്നൽ ലഭിക്കുകയാണെങ്കിൽ, സ്വീകരിക്കുന്ന പ്രക്രിയ അവസാനിക്കുന്നു. എന്നിരുന്നാലും, മിക്ക സിഗ്നൽ തരങ്ങൾക്കും പ്രോസസ്സിന് ഒരു ഹാൻഡ്‌ലർ ഇൻസ്റ്റാൾ ചെയ്യാൻ കഴിയും നൽകിയ സിഗ്നൽഅല്ലെങ്കിൽ ഈ സിഗ്നൽ അവഗണിക്കാൻ സജ്ജമാക്കുക.

ഒരു പ്രോസസ്സ് "സ്വമേധയാ" സസ്പെൻഡ് അവസ്ഥയിലാണെങ്കിൽ (ഉദാഹരണത്തിന്, ഒരു സ്ലീപ്പ് സിസ്റ്റം കോൾ എക്സിക്യൂട്ട് ചെയ്യുന്നതിലൂടെ), തുടർന്ന് "പ്രക്രിയയെ ഉറക്കത്തിൽ നിന്ന് ഉണർത്തുക" എന്ന സിഗ്നൽ സ്വീകരിക്കുന്നു, സിഗ്നൽ പ്രോസസ്സിംഗ് എന്തായിരുന്നാലും, സ്ലീപ്പ് സിസ്റ്റം കോൾ അവസാനിക്കുന്നു. ഉടനെ.

പ്രക്രിയയിലെ സിഗ്നൽ ഹാൻഡ്‌ലർ ഒരു പ്രോട്ടോടൈപ്പുള്ള ഒരു ഫംഗ്‌ഷൻ പോലെ കാണപ്പെടുന്നു:

ശൂന്യം ഫംഗ്‌ഷൻ_നാമം(int sigtype);

ഈ ഫംഗ്ഷൻ്റെ പാരാമീറ്റർ സിഗ്നൽ തരമാണ് (വിവിധ തരത്തിലുള്ള സിഗ്നലുകൾ പ്രോസസ്സ് ചെയ്യുന്നതിന് ഒരേ ഹാൻഡ്ലർ ഇൻസ്റ്റാൾ ചെയ്യാൻ കഴിയും).

നിങ്ങളുടേതായ സിഗ്നൽ ഹാൻഡ്‌ലർ സജ്ജീകരിക്കുന്നതിനോ അത് റദ്ദാക്കുന്നതിനോ അല്ലെങ്കിൽ സിഗ്നൽ അവഗണിക്കാൻ സജ്ജീകരിക്കുന്നതിനോ സിഗ്നൽ സിസ്റ്റം കോൾ ഉപയോഗിക്കുക

സിഗ്നൽ ഹാൻഡ്‌ലർ ഫംഗ്‌ഷനുകളാണ് സാധാരണ പ്രവർത്തനങ്ങൾസി, ആഗോളതലത്തിൽ ദൃശ്യമാകുന്ന എല്ലാ വേരിയബിളുകളിലേക്കും ഫംഗ്ഷനുകളിലേക്കും അവർക്ക് പ്രവേശനമുണ്ട്. എന്നിരുന്നാലും, പ്രോഗ്രാം എക്സിക്യൂഷൻ്റെ ഏത് ഘട്ടത്തിലാണ് ഹാൻഡ്‌ലർ ഫംഗ്‌ഷൻ എന്ന് വിളിക്കപ്പെടുകയെന്ന് ഞങ്ങൾക്ക് അറിയാത്തതിനാൽ, ആക്‌സസ് ചെയ്യുമ്പോൾ ഞങ്ങൾ പ്രത്യേകം ശ്രദ്ധിക്കണം. ആഗോള ഘടനകൾഈ ഫംഗ്ഷനിൽ നിന്നുള്ള ഡാറ്റ. സ്ട്രീമുകൾ പ്രോസസ്സ് ചെയ്യുന്ന ഫംഗ്ഷനുകൾക്ക്, മറ്റൊരു പ്രധാന ആവശ്യകതയുണ്ട് - വീണ്ടും പ്രവേശനം. പ്രോഗ്രാമിൻ്റെ എക്‌സിക്യൂഷൻ്റെ ഏത് ഘട്ടത്തിലും ഒരു സിഗ്നൽ ഹാൻഡ്‌ലറെ വിളിക്കാം (ചില വ്യവസ്ഥകളിൽ, ഒരു സിഗ്നൽ പ്രോസസ്സ് ചെയ്യുമ്പോൾ മറ്റൊരു സിഗ്നൽ ഹാൻഡ്‌ലറെ വിളിക്കാം), ഹാൻഡ്‌ലർമാർ വീണ്ടും പ്രവേശിക്കുന്ന ആവശ്യകതയെ തൃപ്തിപ്പെടുത്തുന്ന ഫംഗ്ഷനുകൾ ഉപയോഗിക്കണം, അതായത് വിളിക്കാം അതേ സമയം. പ്രോഗ്രാമിൽ മറ്റെവിടെയെങ്കിലും അവരെ ഇതിനകം വിളിക്കുമ്പോൾ. വാസ്തവത്തിൽ, ഈ ഉറവിടങ്ങളിലേക്കുള്ള ആക്‌സസ് സമന്വയിപ്പിക്കുന്നതിന് ശ്രദ്ധിക്കാതെ ഒരു ഫംഗ്‌ഷൻ ആഗോള ഉറവിടങ്ങളൊന്നും ഉപയോഗിക്കുന്നില്ലെന്ന് ഉറപ്പാക്കുന്നതിനാണ് വീണ്ടും പ്രവേശിക്കേണ്ട ആവശ്യകത വരുന്നത്. പ്രിൻ്റ്എഫ്() ഫംഗ്‌ഷൻ ഉൾപ്പെടെയുള്ള ചില I/O ഫംഗ്‌ഷനുകൾ വീണ്ടും പ്രവേശിക്കുന്നില്ല. ഒന്നിൻ്റെ സമാപനം എന്നാണ് ഇതിനർത്ഥം printf ഫംഗ്ഷനുകൾ() മറ്റൊരു ഫംഗ്‌ഷൻ്റെ ഔട്ട്‌പുട്ടിൽ ഇടപെട്ടേക്കാം. സിഗ്നൽ ഹാൻഡ്‌ലറുകളിൽ നിന്ന് സുരക്ഷിതമായി വിളിക്കാൻ കഴിയുന്ന റീഎൻറൻ്റ് ഫംഗ്‌ഷനുകളുടെ ഒരു ലിസ്റ്റ് ചുവടെയുണ്ട്.

പുനരാരംഭിക്കുന്ന പ്രവർത്തനങ്ങളുടെ പട്ടിക

posix_trace_event()
timer_getoverrun()

ഒരു പ്രോസസ്സിന് കിൽ സിസ്റ്റം കോൾ ഉപയോഗിച്ച് PID അറിയാവുന്ന മറ്റേതെങ്കിലും പ്രക്രിയയിലേക്ക് ഒരു സിഗ്നൽ അയയ്‌ക്കാൻ കഴിയും (അതിൻ്റെ ദുശ്ശകുനമായ പേര് ഉണ്ടായിരുന്നിട്ടും, ഈ സിസ്റ്റം കോൾ അത് അഭിസംബോധന ചെയ്യുന്ന പ്രക്രിയയെ നശിപ്പിക്കില്ല). ചില സന്ദർഭങ്ങളിൽ, ഒരു പ്രക്രിയയ്ക്ക് സ്വയം ഒരു സിഗ്നൽ അയയ്‌ക്കേണ്ടി വന്നേക്കാം; ഇത് റൈസ് സിസ്റ്റം കോൾ ഉപയോഗിച്ച് ചെയ്യാം.

ചില തരം സിഗ്നലുകൾ

സിഗ്നൽ തരങ്ങൾ സംഖ്യാ സംഖ്യകളാൽ തിരിച്ചറിയപ്പെടുന്നു, പക്ഷേ പ്രോഗ്രാമിംഗ് പലപ്പോഴും ഫയലുകൾ ഉൾപ്പെടുന്ന സിസ്റ്റത്തിൽ നിർവചിച്ചിരിക്കുന്ന പ്രതീകാത്മക സിഗ്നൽ നാമങ്ങൾ ഉപയോഗിക്കുന്നു. ഏറ്റവും സാധാരണയായി ഉപയോഗിക്കുന്ന ചില സിഗ്നൽ നാമങ്ങൾ ചുവടെയുണ്ട്:

	ഈ സിഗ്നൽ അത് സ്വീകരിച്ച പ്രക്രിയ അവസാനിപ്പിക്കുന്നതിന് കാരണമാകുന്നു. അവഗണിക്കാൻ കഴിയാത്തതും നിങ്ങളുടെ സ്വന്തം ഹാൻഡ്‌ലറെ നിയോഗിക്കാൻ കഴിയാത്തതുമായ ഒരേയൊരു സിഗ്നൽ ഇതാണ്
	ഈ സിഗ്നൽ പ്രക്രിയ അവസാനിപ്പിക്കുന്നതിനുള്ള അഭ്യർത്ഥനയാണ്. ഈ സിഗ്നലിൻ്റെ ഇഷ്യൂവിൽ, ഉദാഹരണത്തിന്, കമാൻഡ് ഉൾപ്പെടുന്നു (ഒരു സിസ്റ്റം കോളല്ല!) കിൽ . ഈ സിഗ്നൽ സ്വീകരിക്കുന്ന പ്രക്രിയ അവസാനിക്കുമെന്ന് പ്രതീക്ഷിക്കുന്നു, എന്നാൽ ഒരു പ്രോസസ്സിന് സിഗ്നൽ അവഗണിക്കാനോ അതിന് സ്വന്തം ഹാൻഡ്ലറെ നൽകാനോ തിരഞ്ഞെടുക്കാം.
	ഏതെങ്കിലും ചൈൽഡ് പ്രോസസ്സുകൾ അവസാനിക്കുമ്പോൾ സിസ്റ്റം ഈ സിഗ്നൽ പാരൻ്റ് പ്രോസസിലേക്ക് അയയ്ക്കുന്നു. ഈ സിഗ്നലിനോടുള്ള ഡിഫോൾട്ട് പ്രതികരണം അത് അവഗണിക്കുക എന്നതാണ്. ചൈൽഡ് പ്രോസസുമായി അതിൻ്റെ നിർവ്വഹണം സമന്വയിപ്പിക്കാൻ ഈ സിഗ്നൽ ഉപയോഗിക്കണമെന്നില്ലെങ്കിൽ പാരൻ്റ് പ്രോസസ് പ്രോസസ്സ് ചെയ്യുന്നതിനെക്കുറിച്ച് ശ്രദ്ധിച്ചേക്കില്ല.
	സമയ ഇടവേളകൾ കണക്കാക്കാൻ ഈ സിഗ്നൽ ഉപയോഗിക്കുന്നു. ഒരു പ്രോസസ്സിന് അലാറം അല്ലെങ്കിൽ സെറ്റിടൈമർ സിസ്റ്റം കോളുകൾ ഉപയോഗിച്ചും കാലഹരണപ്പെടുമ്പോഴും സമയ ഇടവേള സജ്ജമാക്കാൻ കഴിയും നിർദ്ദിഷ്ട ഇടവേളസിസ്റ്റം അവന് ഒരു SIGALRM സിഗ്നൽ അയയ്ക്കും.
SIGUSR1, SIGUSR2
	ഈ സിഗ്നലുകൾക്ക് പിന്നിൽ റിസർവ് ചെയ്ത സിഗ്നലുകളൊന്നുമില്ല. സിസ്റ്റം അസൈൻമെൻ്റുകൾ. പ്രക്രിയകൾക്ക് ഈ സിഗ്നലുകൾ പരസ്പരം അയയ്ക്കാനും അവർക്ക് അനുയോജ്യമെന്ന് തോന്നുന്ന രീതിയിൽ വ്യാഖ്യാനിക്കാനും കഴിയും.

സിഗ്നൽ തരങ്ങളെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക്, ഫംഗ്ഷൻ വിവരണം കാണുക

പല Unix പ്രോഗ്രാമുകളും USR1, USR2 തുടങ്ങിയ സിഗ്നലുകൾ സ്വീകരിക്കുന്നു. ഉദാഹരണത്തിന്, അപ്ഡേറ്റ് ചെയ്യാൻ എക്സിക്യൂട്ടബിൾ ഫയൽഈച്ചയിൽ Nginx-ന്, നിങ്ങൾ കിൽ അയയ്‌ക്കുക -USR2 .

USR1 എന്നത് ഒരു "ഉപയോക്താവ്-നിർവചിക്കപ്പെട്ട" സിഗ്നലാണെന്നാണ് എൻ്റെ ധാരണ, അതിനർത്ഥം പ്രോഗ്രാം സൃഷ്ടിച്ചയാൾക്ക് അത് "ഷട്ട് ഡൗൺ" അല്ലെങ്കിൽ "നിങ്ങളുടെ ലോഗുകൾ അൺലോഡ് ചെയ്യുക" അല്ലെങ്കിൽ "ആയിരം തവണ പ്രിൻ്റ് ഫൂ" എന്നോ മറ്റെന്തെങ്കിലുമോ അർത്ഥമാക്കാം. പക്ഷേ എന്തിനാണ് അവർ ഈ ഏകപക്ഷീയമായ പേര് ഉപയോഗിക്കേണ്ടതെന്ന് എനിക്ക് മനസ്സിലാകുന്നില്ല. എന്തുകൊണ്ട് കൊല്ലരുത് -UPGRADE , അല്ലെങ്കിൽ കൊല്ലുക -GRACEFUL_SHUTDOWN ? Unix-ന് ചില സിഗ്നലുകൾ മാത്രമാണോ ഉള്ളത്?

ഞങ്ങൾ അതിൽ ആയിരിക്കുമ്പോൾ, Nginx ഇനിപ്പറയുന്ന സിഗ്നലുകളും ഉപയോഗിക്കുന്നു (ഡോക്യുമെൻ്റേഷൻ കാണുക):

• TERM, INT: പെട്ടെന്നുള്ള ഷട്ട്ഡൗൺ
• പുറത്തുകടക്കുക: ഭംഗിയുള്ള പൂർത്തീകരണം
• HUP:
  • റീബൂട്ട് കോൺഫിഗറേഷൻ
  • പുതിയ കോൺഫിഗറേഷൻ ഉപയോഗിച്ച് പുതിയ വർക്ക്ഫ്ലോകൾ ആരംഭിക്കുക
  • പഴയ വർക്ക്ഫ്ലോകൾ ഭംഗിയായി ഷട്ട്ഡൗൺ ചെയ്യുന്നു
• USR1: ലോഗ് ഫയലുകൾ തുറക്കുക
• USR2: ഈച്ചയിൽ എക്സിക്യൂട്ടബിളുകൾ അപ്ഡേറ്റ് ചെയ്യുക
• വിഞ്ച്: വർക്ക്ഫ്ലോകൾ ഭംഗിയായി അവസാനിപ്പിക്കുക

HUP? വിഞ്ച്? എന്താണ് ഈ പേരുകൾക്ക് കാരണം? എനിക്ക് ഇതിനെക്കുറിച്ച് കൂടുതൽ എവിടെ കണ്ടെത്താനാകും?

6 ഉത്തരങ്ങൾ

OS-ൽ ലഭ്യമായ സിഗ്നലുകൾ OS ആണ് നിർവചിച്ചിരിക്കുന്നത് (സാധാരണയായി POSIX-ന് ശേഷം) - അവ "സ്ട്രിംഗുകൾ" അല്ല, സാധാരണ പേരുകളുള്ള പൂർണ്ണസംഖ്യകളുടെ സ്ഥിരാങ്കങ്ങളാണ്. USR1 ഉം USR2 ഉം പ്രത്യേക അർത്ഥമില്ലാത്ത രണ്ട് സിഗ്നലുകളാണ്, ഡവലപ്പർ ആഗ്രഹിക്കുന്ന ഏത് അനിയന്ത്രിതമായ ഉപയോഗത്തിനും ഉദ്ദേശിച്ചുള്ളതാണ്.

നിങ്ങളുടെ ലിനക്സ് മെഷീൻസിഗ്നലിൻ്റെയും സിഗ്നൽ പ്രോസസ്സിംഗിൻ്റെയും അവലോകനത്തിനായി മാൻ 7 സിഗ്നൽ വായിക്കുക.

ഇവൻ്റുകളോടുള്ള പ്രതികരണമായി ആ സിഗ്നലുകൾ നൽകുന്നതിന് OS-മായി പ്രവർത്തിക്കാൻ നിങ്ങൾ തയ്യാറാണെങ്കിൽ മറ്റ് സിഗ്നലുകളുടെ അർത്ഥം നിങ്ങൾക്ക് അസാധുവാക്കാനാകും. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് HUP എന്നാൽ "കോൺഫിഗറേഷൻ റീലോഡ് ചെയ്യുക" എന്ന് അർത്ഥമാക്കാം - ഒന്നുകിൽ പ്രോസസ്സിന് ഒരു ഹാംഗ് (ടെർമിനലിൻ്റെ നഷ്ടം) ലഭിക്കില്ലെന്ന് നിങ്ങൾക്ക് ഉറപ്പുണ്ടെങ്കിൽ അല്ലെങ്കിൽ ഉപയോക്താവിന് പകരം OS അയക്കുന്ന കേസുകൾ കൈകാര്യം ചെയ്യാൻ നിങ്ങൾ തയ്യാറാണെങ്കിൽ. HUP സിഗ്നൽ.

HUP ഹോവർ ചെയ്യാൻ അനുയോജ്യമല്ല. ഈ സിഗ്നൽ അതിൻ്റെ കൺട്രോൾ ടെർമിനൽ ഫയലിൻ്റെ അവസാനത്തിൽ എത്തിയാൽ ഒരു പ്രോസസ്സിലേക്ക് അയയ്ക്കും. മുൻകാലങ്ങളിൽ, നിയന്ത്രണ ടെർമിനലുകൾ സാധാരണയായി സീരിയൽ പോർട്ടുകളുമായി ബന്ധിപ്പിച്ചിരുന്നു, ഒരുപക്ഷേ ഒരു മോഡം ലൈൻ വഴി ടെലിഫോൺ ലൈൻ. എങ്കിൽ ടെലിഫോൺ കണക്ഷൻഓൺ ചെയ്‌തു, ലോക്കൽ മോഡം കാരിയർ ഡിറ്റക്റ്റ് ലൈൻ താഴ്ത്തുകയും ഒരു കേർണൽ ഫയൽ പൂർത്തീകരണ റിപ്പോർട്ട് അയയ്ക്കുകയും ചെയ്യും. സംപ്രേഷണം ചെയ്ത സിഗ്നൽ SIGHUP.

"വിൻഡോ മാറ്റുന്നതിന്" WINCH അനുയോജ്യമല്ല. അതിൻ്റെ നിയന്ത്രണ ടെർമിനൽ വലിപ്പം മാറ്റുകയാണെങ്കിൽ അത് ഒരു പ്രക്രിയയിലേക്ക് അയയ്‌ക്കും. വ്യക്തമായ കാരണങ്ങളാൽ, വലിപ്പം മാറ്റാൻ കഴിയുന്ന ടെർമിനലുകൾ സാധാരണയായി കപട ടെർമിനലുകളാണ്, അവ ആത്യന്തികമായി ഒരു വിൻഡോ എൻവയോൺമെൻ്റിൽ പ്രവർത്തിക്കുന്ന ഒരു ടെർമിനൽ എമുലേറ്ററാണ് (xterm പോലുള്ളവ) പ്രതിനിധീകരിക്കുന്നത്.

കാരണം സിഗ്നൽ പേരുകൾ സ്റ്റാൻഡേർഡ് ആണ് (POSIX). നിങ്ങൾക്ക് വേണമെങ്കിൽ -അപ്‌ഗ്രേഡ് ചെയ്യാനും USR1 സിഗ്നൽ നൽകാനും നിങ്ങളുടെ സ്വന്തം കിൽ എക്‌സിക്യൂട്ടബിൾ എഴുതാം, എന്നാൽ UNIX-നൊപ്പം വരുന്ന സ്റ്റാൻഡേർഡ് കിൽ അത് തിരിച്ചറിയില്ല.

പകരമായി, നിങ്ങൾക്കായി വിവർത്തനം ചെയ്യാൻ നിങ്ങൾക്ക് ഒരു അപരനാമം, ഫംഗ്ഷൻ അല്ലെങ്കിൽ ഷെൽ സ്ക്രിപ്റ്റ് സൃഷ്ടിക്കാൻ കഴിയും, ഉദാഹരണത്തിന് ഒരു ബാഷ് അപരനാമം ഉപയോഗിച്ച്:

അപരനാമം അപ്‌ഗ്രേഡ്="കിൽ -USR1"

signal.h ഹെഡർ ഫയൽ സിഗ്നൽ പേരുകൾ അവയുടെ യഥാർത്ഥ നടപ്പാക്കലിനെ ആശ്രയിച്ചിരിക്കുന്ന മൂല്യങ്ങളിലേക്ക് മാപ്പ് ചെയ്യുന്നു.

WINCH പദങ്ങളിൽ, ഇത് ഒരു മ്ലേച്ഛതയാണെന്ന് ഞാൻ കരുതുന്നു. വിൻഡോ വലുപ്പം മാറ്റുമ്പോൾ (പ്രത്യേകിച്ച് അവയുടെ കൺട്രോൾ ടെർമിനൽ വിൻഡോ മാറുമ്പോൾ) ആപ്ലിക്കേഷനുകളിലേക്ക് നൽകുന്ന സിഗ്നലാണിത്.

ടെർമിനലിൽ പ്രോസസ്സ് ഒരിക്കലും പ്രവർത്തിക്കില്ലെന്ന് നിങ്ങൾക്ക് ഉറപ്പുനൽകുന്നില്ലെങ്കിൽ വർക്കർ ത്രെഡുകൾ മനോഹരമായി അടയ്ക്കുന്നതിന് ഇത് ഉപയോഗിക്കുന്നത് നല്ല ആശയമല്ല. ഞാൻ ഒരു ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിച്ചാൽ അത് വളരെ മിഥ്യയാകുമെന്ന് എനിക്കറിയാം, ഞാൻ വിൻഡോ പരമാവധിയാക്കിയത് കാരണം ഫ്ലൈറ്റിലെ എല്ലാ ജോലികളും റദ്ദാക്കാൻ അത് തീരുമാനിച്ചു :-)

കിൽ-എൽ പരീക്ഷിച്ച് ഉത്തരം സ്വയം കണ്ടെത്തുക:

1) സൈഗ്അപ്പ് 2) സിഗ്വിറ്റ് 3) സിഗ്വിറ്റ് 4) സിഗിൽ 5) സിഗ്‌ട്രാപ്പ് 6) സിഗാബർട്ട് 7) സിഗ്ബസ് 8) സിഗ്എഫ്‌പി 9) സിഗ്‌കിൽ 10) സിഗസ്ആർ 1 11) സിഗ്‌സെഗ്വ് 12) സിഗ്‌സെഗ്‌വ് 12) സിഗ്എസ്ആർഐജിഎം എസ്ഇജിഎസ്ആർ 2) 13) KFLT 17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP 21) SIGTTIN 22) SIGTTOU 23) SIGURG 24) SIGXCPU 25) SIGXFSZ 26) SIGVTALRM 27) SIGROF 39 INCHIGO) SYS 34) SIGRTMIN 35) SIGRTMIN+ 1 36) SIGRTMIN+2 37) SIGRTMIN+3 38) SIGRTMIN+4 39) SIGRTMIN+5 40) SIGRTMIN+6 41) SIGRTMIN+7 42) SIGRTMIN+8 43) SIGRTMIN+9 44) SIGRTMIN56+10) ) SIGRTMIN+12 47) SIGRTMIN+13 48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12 53) SIGRTMAX-109 SIGRTMAX-11 541) ) SIGRTMAX-8 57) SIGRTMAX-7 58) SIGRTMAX-6 59) SIGRTMAX-5 60) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-2 63) SIGRTMAX-1 64) SIGRTMAX