දැනටමත් ක්‍රියාත්මක වන ක්‍රියාවලියක් nohup යටතේ තබන්නේ කෙසේද?

මට දැනටමත් දීර් process කාලයක් තිස්සේ ක්‍රියාත්මක වන ක්‍රියාවලියක් ඇති අතර එය අවසන් කිරීමට අවශ්‍ය නැත.

මම එය නොහප් යටතේ තබන්නේ කෙසේද (එනම්, මම පර්යන්තය වසා දැමුවද එය දිගටම ක්‍රියාත්මක වීමට හේතු වන්නේ කෙසේද?)

ක්‍රියාවලිය පසුබිමට යැවීම සඳහා රැකියා පාලනය බාෂ් භාවිතා කිරීම :

1. Ctrl+ Zවැඩසටහන නැවැත්වීමට (විරාමයක් තබා) නැවත කවචයට යන්න.
2. bg එය පසුබිමේ ධාවනය කිරීමට.
3. disown -h [job-spec]එහිදී [job-spec] යනු රැකියා අංකයයි ( %1පළමු ධාවනය වන රැකියාව මෙන්; jobsවිධානය සමඟ ඔබේ අංකය සොයා ගන්න ) එවිට ටර්මිනලය වැසෙන විට රැකියාව මිය නොයනු ඇත.

කිසියම් හේතුවක් නිසා Ctrl+ Zද ක්‍රියා නොකරයි යැයි සිතමු , වෙනත් පර්යන්තයකට ගොස් ක්‍රියාවලි හැඳුනුම්පත (භාවිතා කරමින් ps) සොයාගෙන ධාවනය කරන්න:

kill -SIGSTOP PID 
kill -SIGCONT PID

SIGSTOPක්‍රියාවලිය අත්හිටුවන අතර SIGCONTපසුබිම තුළ ක්‍රියාවලිය නැවත ආරම්භ කරනු ඇත. දැන්, ඔබේ පර්යන්ත දෙකම වසා දැමීමෙන් ඔබේ ක්‍රියාවලිය නතර නොවේ.

ක්‍රියාත්මක වන කාර්යය කවචයෙන් වෙන් කිරීමේ විධානය (= එය නොහප් බවට පත් කරයි) disownසහ මූලික ෂෙල්-විධානයකි.

Bash-manpage වෙතින් (man bash):

disown [-ar] [-h] [jobspec ...]

විකල්ප නොමැතිව, එක් එක් රැකියා ස්ථානය සක්‍රිය රැකියා වගුවෙන් ඉවත් කරනු ලැබේ. -H විකල්පය ලබා දී ඇත්නම්, සෑම රැකියා ස්ථානයක්ම මේසයෙන් ඉවත් නොකෙරේ, නමුත් සලකුණු කර ඇති අතර එමඟින් ෂෙල් එකට SIGHUP එකක් ලැබෙන්නේ නම් SIGHUP රැකියාවට නොයවනු ඇත. රැකියා ස්ථානයක් නොමැති නම් සහ -a හෝ -r විකල්පය සපයා නොමැති නම්, වර්තමාන රැකියාව භාවිතා වේ. රැකියා අවකාශයක් සපයා නොමැති නම්, -a විකල්පය යනු සියලු රැකියා ඉවත් කිරීම හෝ සලකුණු කිරීම ය; ජොබ්ස්පෙක් තර්කයක් නොමැතිව -r විකල්පය ක්‍රියාත්මක වන රැකියා සඳහා සීමා කරයි. රැකියා ස්ථානයක් වලංගු රැකියාවක් නියම නොකරන්නේ නම් ප්‍රතිලාභ අගය 0 වේ.

ඒ කියන්නේ සරලයි

disown -a

සියලු රැකියා රැකියා වගුවෙන් ඉවත් කර ඔවුන්ව නොහොබිනා බවට පත් කරයි

මේවා ඉහත හොඳ පිළිතුරු, මට පැහැදිලි කිරීමක් එක් කිරීමට අවශ්‍ය විය:

ඔබට රැකියාවක් disownහෝ ක්‍රියාවලියක් කළ නොහැක , ඔබ disownරැකියාවක් වන අතර එය වැදගත් වෙනසකි.

රැකියාවක් යනු කවචයකට සම්බන්ධ කර ඇති ක්‍රියාවලියක් පිළිබඳ සංකල්පයකි, එබැවින් ඔබ එම කාර්යය පසුබිමට විසි කළ යුතුය (එය අත්හිටුවීම නොවේ) ඉන්පසු එය ප්‍රතික්ෂේප කරන්න.

නිකුත් කිරීම:

%  jobs
[1]  running java 
[2]  suspended vi
%  disown %1

යුනික්ස් රැකියා පාලනය පිළිබඳ වඩාත් සවිස්තරාත්මක සාකච්ඡාවක් සඳහා http://www.quantprinciple.com/invest/index.php/docs/tipsandtricks/unix/jobcontrol/ බලන්න .

අවාසනාවකට disownබැෂ් සඳහා විශේෂිත වන අතර සියලුම ෂෙල් වෙඩි වල නොමැත.

යුනික්ස් හි සමහර රසයන් (උදා: AIX සහ Solaris) nohupවිධානය මතම විකල්පයක් ඇති අතර එය ක්‍රියාත්මක වන ක්‍රියාවලියකට යෙදිය හැකිය:

nohup -p pid

Http://en.wikipedia.org/wiki/Nohup බලන්න

නෝඩ්ගේ පිළිතුර ඇත්තෙන්ම විශිෂ්ටයි, නමුත් එය stdout සහ stderr යළි හරවා යැවිය හැක්කේ කෙසේද යන ප්‍රශ්නය විවෘත කළේය. මම යුනික්ස් සහ ලිනක්ස් වෙතින් විසඳුමක් සොයා ගත්තෙමි , නමුත් එය ද සම්පූර්ණ නැත. මෙම විසඳුම් දෙක ඒකාබද්ධ කිරීමට මම කැමතියි. මේ තියෙන්නේ:

මගේ පරීක්ෂණය සඳහා මම loop.sh නමින් කුඩා බෑෂ් ස්ක්‍රිප්ට් එකක් සාදන ලද අතර එය අනන්ත පුඩුවක් තුළ විනාඩියක නින්දක් සහිතව මුද්‍රණය කරයි.

$./loop.sh

දැන් කෙසේ හෝ මෙම ක්‍රියාවලියේ PID ලබා ගන්න. සාමාන්යයෙන් ps -C loop.shප්රමාණවත් තරම් හොඳයි, නමුත් එය මගේ නඩුවේ මුද්රණය කර ඇත.

දැන් අපට වෙනත් පර්යන්තයකට මාරු විය හැකිය (නැතහොත් ^ Z ඔබන්න සහ එකම පර්යන්තයේ). දැන් gdbමෙම ක්‍රියාවලියට අනුයුක්ත කළ යුතුය.

$ gdb -p <PID>

මෙය ස්ක්‍රිප්ට් එක නවත්වයි (ක්‍රියාත්මක වන්නේ නම්). එහි තත්වය පරීක්ෂා කළ හැකියps -f <PID> කොහෙද, STATක්ෂේත්රය 'T +' (හෝ ^ Z "ටී" නඩුවේ), ඒ කියන්නේ, (මිනිසා ps (1)) යනු

    T Stopped, either by a job control signal or because it is being traced
    + is in the foreground process group

(gdb) call close(1)
$1 = 0

වසන්න (1) සාර්ථකත්වයේ ශුන්‍යය ලබා දෙයි.

(gdb) call open("loop.out", 01102, 0600)
$6 = 1

විවෘත (1) සාර්ථක නම් නව ගොනු විස්තරය නැවත ලබා දෙයි.

මෙම විවෘත කිරීම සමාන වේ open(path, O_TRUNC|O_CREAT|O_RDWR, S_IRUSR|S_IWUSR). O_RDWR O_WRONLYයෙදිය හැකි වෙනුවට , නමුත් /usr/sbin/lsofසියලුම std * ගොනු හසුරුවන්නන් සඳහා 'u' පවසයි (FD තීරුව) , එනම් O_RDWR.

මම /usr/include/bits/fcntl.h ශීර්ෂ ගොනුවේ අගයන් පරික්ෂා කළෙමි.

ප්රතිදානය ගොනු විවෘත කළ හැකි O_APPENDලෙස, nohupකරන්නේ, නමුත් මේ මගින් යෝජනා කර නැතman open(2) නිසා හැකි NFS ගැටලු.

අපි ලබා නම් -1 ආපසු වටිනාකමක් ලෙස, පසුව call perror("")එම දෝශ පණිවිඩය මුද්රණය කරයි. අපට දෝෂය අවශ්‍ය නම්, p errnogdb comand භාවිතා කරන්න .

දැන් අපට අලුතින් හරවා යවන ලද ගොනුව පරීක්ෂා කළ හැකිය. /usr/sbin/lsof -p <PID>මුද්‍රණ:

loop.sh <PID> truey    1u   REG   0,26        0 15008411 /home/truey/loop.out

අපට අවශ්ය නම්, අප stderr තවත් ගොනුවක්, අපි භාවිතා කිරීමට අවශ්ය නම්, නැවත හැරවීම හැකි call close(2)හාcall open(...) වෙනත් ගොනු නාමයක් නැවත භාවිතා .

දැන් අමුණා bashඇති නිදහස් කළ යුතු අතර අපට ඉවත් විය හැකිය gdb:

(gdb) detach
Detaching from program: /bin/bash, process <PID>
(gdb) q

ස්ක්‍රිප්ට් එක gdbවෙනත් පර්යන්තයකින් නැවැත්වූයේ නම් එය දිගටම ක්‍රියාත්මක වේ. අපට නැවත loop.sh හි පර්යන්තය වෙත මාරු විය හැකිය. දැන් එය තිරයට කිසිවක් ලියන්නේ නැත, නමුත් ධාවනය කර ගොනුව තුළට ලිවීම. අපි එය පසුබිමට දැමිය යුතුයි. එබැවින් ඔබන්න ^Z.

^Z
[1]+  Stopped                 ./loop.sh

(දැන් අප සිටින්නේ ^Zආරම්භයේ දී එබූ ආකාරයටම ය .)

දැන් අපට රැකියාවේ තත්වය පරීක්ෂා කළ හැකිය:

$ ps -f 24522
UID        PID  PPID  C STIME TTY      STAT   TIME CMD
<UID>    <PID><PPID>  0 11:16 pts/36   S      0:00 /bin/bash ./loop.sh
$ jobs
[1]+  Stopped                 ./loop.sh

එබැවින් ක්‍රියාවලිය පසුබිමේ ක්‍රියාත්මක විය යුතු අතර පර්යන්තයෙන් වෙන් කළ යුතුය. jobsවර්ග වරහන් වල විධානයේ ප්‍රතිදානයේ අංකය ඇතුළත කාර්යය හඳුනා ගනී bash. bashරැකියා අංකයට පෙර '%' ලකුණක් යොදන පහත දැක්වෙන විධාන වලින් අපට භාවිතා කළ හැකිය :

$ bg %1
[1]+ ./loop.sh &
$ disown -h %1
$ ps -f <PID>
UID        PID  PPID  C STIME TTY      STAT   TIME CMD
<UID>    <PID><PPID>  0 11:16 pts/36   S      0:00 /bin/bash ./loop.sh

දැන් අපට ඇමතුම් බැෂ් එකෙන් ඉවත් විය හැකිය. ක්‍රියාවලිය පසුබිමේ දිගටම ක්‍රියාත්මක වේ. අපි එහි PPID එකෙන් ඉවත් වුවහොත් 1 (init (1) ක්‍රියාවලිය) බවට පත් වන අතර පාලක පර්යන්තය නොදැනේ.

$ ps -f <PID>
UID        PID  PPID  C STIME TTY      STAT   TIME CMD
<UID>    <PID>     1  0 11:16 ?        S      0:00 /bin/bash ./loop.sh
$ /usr/bin/lsof -p <PID>
...
loop.sh <PID> truey    0u   CHR 136,36                38 /dev/pts/36 (deleted)
loop.sh <PID> truey    1u   REG   0,26     1127 15008411 /home/truey/loop.out
loop.sh <PID> truey    2u   CHR 136,36                38 /dev/pts/36 (deleted)

COMMENT

විධාන අඩංගු ගොනුවක් (උදා: loop.gdb) නිර්මාණය කරමින් gdb දේවල් ස්වයංක්‍රීය කළ හැකිය gdb -q -x loop.gdb -p <PID>. මගේ loop.gdb මේ වගේ:

call close(1)
call open("loop.out", 01102, 0600)
# call close(2)
# call open("loop.err", 01102, 0600)
detach
quit

නැතහොත් ඒ වෙනුවට පහත දැක්වෙන එක් ලයිනර් භාවිතා කළ හැකිය:

gdb -q -ex 'call close(1)' -ex 'call open("loop.out", 01102, 0600)' -ex detach -ex quit -p <PID>

මෙය විසඳුම පිළිබඳ තරමක් සම්පූර්ණ විස්තරයක් යැයි මම බලාපොරොත්තු වෙමි.

ධාවන ක්‍රියාවලිය nohup වෙත යැවීමට ( http://en.wikipedia.org/wiki/Nohup )

nohup -p pid , එය මට වැඩ කළේ නැත

පසුව මම පහත දැක්වෙන විධානයන් අත්හදා බැලූ අතර එය ඉතා හොඳින් ක්‍රියාත්මක විය

1. SOMECOMMAND ටිකක් ධාවනය කරන්න, කියන්න /usr/bin/python /vol/scripts/python_scripts/retention_all_properties.py 1.

2. Ctrl+ Zවැඩසටහන නැවැත්වීමට (විරාමයක් තබා) නැවත කවචයට යන්න.

3. bg එය පසුබිමේ ධාවනය කිරීමට.

4. disown -h එවිට පර්යන්තය වැසෙන විට ක්‍රියාවලිය මරණයට පත් නොවේ.

5. exitෂෙල් එකෙන් පිටතට යාමට ටයිප් කරන්න, මන්දයත් දැන් ඔබ යා යුතු බැවින් මෙහෙයුම එහි ක්‍රියාවලිය තුළ පසුබිමේ ක්‍රියාත්මක වන බැවින් එය ෂෙල් එකකට බැඳී නැත.

මෙම ක්‍රියාවලිය ධාවනය කිරීමට සමාන වේ nohup SOMECOMMAND.

මගේ AIX පද්ධතියේ, මම උත්සාහ කළා

nohup -p  processid>

මෙය හොඳින් ක්‍රියාත්මක විය. ටර්මිනල් කවුළු වසා දැමීමෙන් පසුව පවා එය මගේ ක්‍රියාවලිය දිගටම කරගෙන ගියේය. මෙම නිසා අපි සුපුරුදු shell එක ලෙස ksh ඇති bgහා disownවිධාන වැඩ කටයුතු කළේ නැත.

1. ctrl+ z - මෙය රැකියාව විරාමයක් ලබා දෙනු ඇත (අවලංගු කිරීමට යන්නේ නැත!)
2. bg - මෙය කාර්යය පසුබිමට ගෙන නැවත ධාවන ක්‍රියාවලියට යොමු කරනු ඇත
3. disown -a - මෙය රැකියාව සමඟ ඇති සියලුම ඇමුණුම් කපා දමනු ඇත (එබැවින් ඔබට පර්යන්තය වසා දැමිය හැකි අතර එය තවමත් ක්‍රියාත්මක වේ)

මෙම සරල පියවර මඟින් ක්‍රියාවලිය දිගටම කරගෙන යන අතර පර්යන්තය වසා දැමීමට ඔබට ඉඩ සලසයි.

එය ක්‍රියාත්මක nohupනොවනු ඇත (ඔබගේ ප්‍රශ්නය පිළිබඳ මගේ අවබෝධය මත පදනම්ව, ඔබට එය මෙහි අවශ්‍ය නොවේ).

මෙය tcshell හි සිටියදී උබුන්ටු ලිනක්ස් සඳහා මට වැඩ කළේය.

1. CtrlZ එය විරාමයක් ගැනීමට

2. bg පසුබිමේ ධාවනය කිරීමට

3. jobs එහි රැකියා අංකය ලබා ගැනීමට

4. nohup %n මෙහි n යනු රැකියා අංකයයි