blocks|key|277838|text|假设您有(或可以很容易地创建)一个pid文件来跟踪孩子的pid，那么您可以创建一个脚本来检查pid文件的modtime，并根据需要终止/重新启动进程。然后，只需将脚本放在crontab中，以便在大约需要的时间段运行。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|277839|如果你需要更多细节，请告诉我。如果这听起来不能满足您的需求，那么upstart?呢|offset|length|277840|entityMap|0|LINK|mutability|MUTABLE|url|http://upstart.ubuntu.com/^0|0|W|8|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

Assuming you have (or can easily make) a pid file for tracking the child's pid, you could then create a script that checks the modtime of the pid file and kills/respawns the process as needed. Then just put the script in crontab to run at approximately the period you need.

Let me know if you need more details. If that doesn't sound like it'd suit your needs, what about <a href="http://upstart.ubuntu.com/" rel="nofollow">upstart?</a>

blocks|key|279572|text|sleep+999&
t=$!
sleep+10
kill+$t|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|279573|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>sleep 999&amp;
t=$!
sleep 10
kill $t
</code></pre>

blocks|key|277842|text|(见：)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|277843|如果你不介意下载一些东西，可以使用timeout+(sudo+apt-get+install+timeout)并像这样使用它：(大多数系统已经安装了它，否则就使用sudo+apt-get+install+coreutils)|offset|length|style|CODE|277844|timeout+10+ping+www.goooooogle.com|code-block|syntax|javascript|277845|如果你不想下载什么东西，可以在内部执行timeout：|277846|(+cmdpid=$BASHPID;+(sleep+10;+kill+$cmdpid)+&+exec+ping+www.goooooogle.com+)|277847|如果您想对更长的bash代码执行超时，请使用第二个选项：|277848|(+cmdpid=$BASHPID;+
++++(sleep+10;+kill+$cmdpid)+\
+++&+while+!+ping+-w+1+www.goooooogle.com+
+++++do+
+++++++++echo+crap;+
+++++done+)|277849|entityMap^0|0|H|7|Q|S|29|U|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@$D|Y|E|Z|F|G]|$D|10|E|11|F|G]|$D|12|E|13|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|14|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|16|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|17|8|@]|9|@]|A|$]]|$1|S|3|T|5|J|7|18|8|@]|9|@]|A|$K|L]]|$1|U|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|V|$]]

(As seen in:
<a href="http://mywiki.wooledge.org/BashFAQ/068" rel="noreferrer">BASH FAQ entry #68: "How do I run a command, and have it abort (timeout) after N seconds?"</a>)

If you don't mind downloading something, use <code>timeout</code> (<code>sudo apt-get install timeout</code>) and use it like: (most Systems have it already installed otherwise use <code>sudo apt-get install coreutils</code>)

<pre><code>timeout 10 ping www.goooooogle.com
</code></pre>

If you don't want to download something, do what timeout does internally:

<pre><code>( cmdpid=$BASHPID; (sleep 10; kill $cmdpid) &amp; exec ping www.goooooogle.com )
</code></pre>

In case that you want to do a timeout for longer bash code, use the second option as such:

<pre><code>( cmdpid=$BASHPID; 
 (sleep 10; kill $cmdpid) \
 &amp; while ! ping -w 1 www.goooooogle.com 
 do 
 echo crap; 
 done )
</code></pre>

blocks|key|3198936|text|#+Spawn+a+child+process:
(dosmth)+&+pid=$!
#+in+the+background,+sleep+for+10+secs+then+kill+that+process
(sleep+10+&&+kill+-9+$pid)+&|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3198937|或者也可以获取退出代码：|unstyled|3198938|#+Spawn+a+child+process:
(dosmth)+&+pid=$!
#+in+the+background,+sleep+for+10+secs+then+kill+that+process
(sleep+10+&&+kill+-9+$pid)+&+waiter=$!
#+wait+on+our+worker+process+and+return+the+exitcode
exitcode=$(wait+$pid+&&+echo+$?)
#+kill+the+waiter+subshell,+if+it+still+runs
kill+-9+$waiter+2>/dev/null
#+0+if+we+killed+the+waiter,+cause+that+means+the+process+finished+before+the+waiter
finished_gracefully=$?|3198939|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code># Spawn a child process:
(dosmth) &amp; pid=$!
# in the background, sleep for 10 secs then kill that process
(sleep 10 &amp;&amp; kill -9 $pid) &amp;
</code></pre>

or to get the exit codes as well:

<pre><code># Spawn a child process:
(dosmth) &amp; pid=$!
# in the background, sleep for 10 secs then kill that process
(sleep 10 &amp;&amp; kill -9 $pid) &amp; waiter=$!
# wait on our worker process and return the exitcode
exitcode=$(wait $pid &amp;&amp; echo $?)
# kill the waiter subshell, if it still runs
kill -9 $waiter 2&gt;/dev/null
# 0 if we killed the waiter, cause that means the process finished before the waiter
finished_gracefully=$?
</code></pre>

blocks|key|2985524|text|一种方法是在子subshell中运行该程序，并使用read命令通过命名管道与该子subshell通信。这样，您就可以检查正在运行的进程的退出状态，并通过管道将其传回。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2985525|下面是一个在3秒后使yes命令超时的示例。它使用pgrep获取进程的PID+(可能只在Linux上有效)。使用管道也有一些问题，因为打开管道进行读取的进程将挂起，直到它也打开进行写入，反之亦然。因此，为了防止read命令挂起，我使用一个背景子外壳“楔入”打开管道进行读取。(另一种防止冻结的方法是打开管道读写，即read+-t+5+<>finished.pipe+-然而，这也可能不起作用，除非在Linux上。)|2985526|rm+-f+finished.pipe
mkfifo+finished.pipe

{+yes+>/dev/null;+echo+finished+>finished.pipe+;+}+&
SUBSHELL=$!

#+Get+command+PID
while+:+;+do
++++PID=$(+pgrep+-P+$SUBSHELL+yes+)
++++test+"$PID"+=+""+%7C%7C+break
++++sleep+1
done

#+Open+pipe+for+writing
{+exec+4>finished.pipe+;+while+:+;+do+sleep+1000;+done+}+&++

read+-t+3+FINISHED+<finished.pipe

if+[+"$FINISHED"+=+finished+]+;+then
++echo+'Subprocess+finished'
else
++echo+'Subprocess+timed+out'
++kill+$PID
fi

rm+finished.pipe|code-block|syntax|javascript|2985527|entityMap^0|P|4|0|A|3|O|5|2W|4|4C|P|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|N|$]]

One way is to run the program in a subshell, and communicate with the subshell through a named pipe with the <code>read</code> command. This way you can check the exit status of the process being run and communicate this back through the pipe.

Here's an example of timing out the <code>yes</code> command after 3 seconds. It gets the PID of the process using <code>pgrep</code> (possibly only works on Linux). There is also some problem with using a pipe in that a process opening a pipe for read will hang until it is also opened for write, and vice versa. So to prevent the <code>read</code> command hanging, I've "wedged" open the pipe for read with a background subshell. (Another way to prevent a freeze to open the pipe read-write, i.e. <code>read -t 5 &lt;&gt;finished.pipe</code> - however, that also may not work except with Linux.)

<pre><code>rm -f finished.pipe
mkfifo finished.pipe

{ yes &gt;/dev/null; echo finished &gt;finished.pipe ; } &amp;
SUBSHELL=$!

# Get command PID
while : ; do
 PID=$( pgrep -P $SUBSHELL yes )
 test "$PID" = "" || break
 sleep 1
done

# Open pipe for writing
{ exec 4&gt;finished.pipe ; while : ; do sleep 1000; done } &amp; 

read -t 3 FINISHED &lt;finished.pipe

if [ "$FINISHED" = finished ] ; then
 echo 'Subprocess finished'
else
 echo 'Subprocess timed out'
 kill $PID
fi

rm finished.pipe
</code></pre>

blocks|key|279587|text|我也有这个问题，我发现另外两件事非常有用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|279588|bash中的秒变量。|279589|命令“pgrep”。|unordered-list-item|279590|279591|因此，我在命令行(OSX+10.9)中使用类似以下内容：|279592|ping+www.goooooogle.com+&+PING_PID=$(pgrep+'ping');+SECONDS=0;+while+pgrep+-q+'ping';+do+sleep+0.2;+if+[+$SECONDS+=+10+];+then+kill+$PING_PID;+fi;+done|code-block|syntax|javascript|279593|因为这是一个循环，所以我包含了一个“睡眠0.2”来保持CPU的冷却。;-)|279594|(顺便说一句:+ping是一个糟糕的例子，您只需使用内置的"-t“(超时)选项即可。)|279595|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|X|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|Y|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|Z|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

I also had this question and found two more things very useful:

<ol>
<li>The SECONDS variable in bash.</li>
<li>The command "pgrep".</li>
</ol>

So I use something like this on the command line (OSX 10.9):

<pre><code>ping www.goooooogle.com &amp; PING_PID=$(pgrep 'ping'); SECONDS=0; while pgrep -q 'ping'; do sleep 0.2; if [ $SECONDS = 10 ]; then kill $PING_PID; fi; done
</code></pre>

As this is a loop I included a "sleep 0.2" to keep the CPU cool. ;-)

(BTW: ping is a bad example anyway, you just would use the built-in "-t" (timeout) option.)

blocks|key|3198991|text|这里有一种尝试，它试图避免在进程已经退出后杀死它，这降低了杀死具有相同进程ID的另一个进程的机会(尽管可能不可能完全避免这种错误)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3198992|run_with_timeout+()
{
++t=$1
++shift

++echo+"running+\"$*\"+with+timeout+$t"

++(
++#+first,+run+process+in+background
++(exec+sh+-c+"$*")+&
++pid=$!
++echo+$pid

++#+the+timeout+shell
++(sleep+$t+;+echo+timeout)+&
++waiter=$!
++echo+$waiter

++#+finally,+allow+process+to+end+naturally
++wait+$pid
++echo+$?
++)+\
++%7C+(read+pid
+++++read+waiter

+++++if+test+$waiter+!=+timeout+;+then
+++++++read+status
+++++else
+++++++status=timeout
+++++fi

+++++#+if+we+timed+out,+kill+the+process
+++++if+test+$status+=+timeout+;+then
+++++++kill+$pid
+++++++exit+99
+++++else
+++++++#+if+the+program+exited+normally,+kill+the+waiting+shell
+++++++kill+$waiter
+++++++exit+$status
+++++fi
++)
}|code-block|syntax|javascript|3198993|像run_with_timeout+3+sleep+10000一样使用，它运行sleep+10000，但在3秒后结束它。|offset|length|style|CODE|3198994|这就像其他答案一样，它使用后台超时进程在延迟后杀死子进程。我认为这几乎与丹的扩展回答(https://stackoverflow.com/a/5161274/1351983)相同，只是超时外壳在超时外壳已经结束时不会被终止。|3198995|在这个程序结束之后，仍然会有一些持续的“睡眠”进程在运行，但它们应该是无害的。|3198996|这可能是一个比我的其他答案更好的解决方案，因为它没有使用不可移植的外壳特性read+-t，也没有使用pgrep。|3198997|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/5161274/1351983^0|0|0|1|U|13|B|0|17|17|0|0|0|11|7|1E|5|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@$I|13|J|14|K|L]|$I|15|J|16|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|17|8|@]|9|@$I|18|J|19|1|1A]]|A|$]]|$1|O|3|P|5|6|7|1B|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1C|8|@$I|1D|J|1E|K|L]|$I|1F|J|1G|K|L]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

Here's an attempt which tries to avoid killing a process after it has already exited, which reduces the chance of killing another process with the same process ID (although it's probably impossible to avoid this kind of error completely).

<pre><code>run_with_timeout ()
{
 t=$1
 shift

 echo "running \"$*\" with timeout $t"

 (
 # first, run process in background
 (exec sh -c "$*") &amp;
 pid=$!
 echo $pid

 # the timeout shell
 (sleep $t ; echo timeout) &amp;
 waiter=$!
 echo $waiter

 # finally, allow process to end naturally
 wait $pid
 echo $?
 ) \
 | (read pid
 read waiter

 if test $waiter != timeout ; then
 read status
 else
 status=timeout
 fi

 # if we timed out, kill the process
 if test $status = timeout ; then
 kill $pid
 exit 99
 else
 # if the program exited normally, kill the waiting shell
 kill $waiter
 exit $status
 fi
 )
}
</code></pre>

Use like <code>run_with_timeout 3 sleep 10000</code>, which runs <code>sleep 10000</code> but ends it after 3 seconds.

This is like other answers which use a background timeout process to kill the child process after a delay. I think this is almost the same as Dan's extended answer (<a href="https://stackoverflow.com/a/5161274/1351983">https://stackoverflow.com/a/5161274/1351983</a>), except the timeout shell will not be killed if it has already ended.

After this program has ended, there will still be a few lingering "sleep" processes running, but they should be harmless.

This may be a better solution than my other answer because it does not use the non-portable shell feature <code>read -t</code> and does not use <code>pgrep</code>.

blocks|key|275972|text|这是我在这里提交的第三个答案。这个函数处理信号中断，并在接收到SIGINT时清理后台进程。它使用top+answer中使用的$BASHPID和exec技巧来获取进程的PID+(在本例中是sh调用中的$$+)。它使用FIFO与负责杀死和清理的子subshell进行通信。(这类似于我的second+answer中的管道，但拥有一个命名管道意味着信号处理程序也可以写入其中。)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|275973|run_with_timeout+()
{
++t=$1+;+shift

++trap+cleanup+2

++F=$$.fifo+;+rm+-f+$F+;+mkfifo+$F

++#+first,+run+main+process+in+background
++"$@"+&+pid=$!

++#+sleeper+process+to+time+out
++(+sh+-c+"echo+\$\$+>$F+;+exec+sleep+$t"+;+echo+timeout+>$F+)+&
++read+sleeper+<$F

++#+control+shell.+read+from+fifo.
++#+final+input+is+"finished".++after+that
++#+we+clean+up.++we+can+get+a+timeout+or+a
++#+signal+first.
++(+exec+0<$F
++++while+:+;+do
++++++read+input
++++++case+$input+in
++++++++finished)
++++++++++test+$sleeper+!=+0+&&+kill+$sleeper
++++++++++rm+-f+$F
++++++++++exit+0
++++++++++;;
++++++++timeout)
++++++++++test+$pid+!=+0+&&+kill+$pid
++++++++++sleeper=0
++++++++++;;
++++++++signal)
++++++++++test+$pid+!=+0+&&+kill+$pid
++++++++++;;
++++++esac
++++done
++)+&

++#+wait+for+process+to+end
++wait+$pid
++status=$?
++echo+finished+>$F
++return+$status
}

cleanup+()
{
++echo+signal+>$$.fifo
}|code-block|syntax|javascript|275974|我已经尽可能地避免了竞态条件。然而，我无法消除的一个错误来源是，当进程结束时，几乎与超时时间相同。例如，run_with_timeout+2+sleep+2或run_with_timeout+0+sleep+0。对我来说，后者给出了一个错误：|275975|timeout.sh:+line+250:+kill:+(23248)+-+No+such+process|275976|因为它正试图杀死一个已经自行退出的进程。|275977|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/5161258/1351983|1|https://stackoverflow.com/a/44248920/1351983^0|V|6|1Q|8|1Z|4|2L|2|2R|2|1C|A|0|3X|D|1|0|0|1G|Q|27|Q|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@$9|1B|A|1C|1|1D]|$9|1E|A|1F|1|1G]]|E|$]]|$1|F|3|G|5|H|7|1H|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1I|8|@$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|1N|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1O|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1P|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]|Y|$5|T|U|V|E|$W|Z]]]]

Here's the third answer I've submitted here. This one handles signal interrupts and cleans up background processes when <code>SIGINT</code> is received. It uses the <code>$BASHPID</code> and <code>exec</code> trick used in the <a href="https://stackoverflow.com/a/5161258/1351983">top answer</a> to get the PID of a process (in this case <code>$$</code> in a <code>sh</code> invocation). It uses a FIFO to communicate with a subshell that is responsible for killing and cleanup. (This is like the pipe in my <a href="https://stackoverflow.com/a/44248920/1351983">second answer</a>, but having a named pipe means that the signal handler can write into it too.)

<pre><code>run_with_timeout ()
{
 t=$1 ; shift

 trap cleanup 2

 F=$$.fifo ; rm -f $F ; mkfifo $F

 # first, run main process in background
 "$@" &amp; pid=$!

 # sleeper process to time out
 ( sh -c "echo \$\$ &gt;$F ; exec sleep $t" ; echo timeout &gt;$F ) &amp;
 read sleeper &lt;$F

 # control shell. read from fifo.
 # final input is "finished". after that
 # we clean up. we can get a timeout or a
 # signal first.
 ( exec 0&lt;$F
 while : ; do
 read input
 case $input in
 finished)
 test $sleeper != 0 &amp;&amp; kill $sleeper
 rm -f $F
 exit 0
 ;;
 timeout)
 test $pid != 0 &amp;&amp; kill $pid
 sleeper=0
 ;;
 signal)
 test $pid != 0 &amp;&amp; kill $pid
 ;;
 esac
 done
 ) &amp;

 # wait for process to end
 wait $pid
 status=$?
 echo finished &gt;$F
 return $status
}

cleanup ()
{
 echo signal &gt;$$.fifo
}
</code></pre>

I've tried to avoid race conditions as far as I can. However, one source of error I couldn't remove is when the process ends near the same time as the timeout. For example, <code>run_with_timeout 2 sleep 2</code> or <code>run_with_timeout 0 sleep 0</code>. For me, the latter gives an error:

<pre><code>timeout.sh: line 250: kill: (23248) - No such process
</code></pre>

as it is trying to kill a process that has already exited by itself.

blocks|key|3199123|text|#Kill+command+after+10+seconds
timeout+10+command

#If+you+don't+have+timeout+installed,+this+is+almost+the+same:
sh+-c+'(sleep+10;+kill+"$$")+&+command'

#The+same+as+above,+with+muted+duplicate+messages:
sh+-c+'(sleep+10;+kill+"$$"+2>/dev/null)+&+command'|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3199124|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>#Kill command after 10 seconds
timeout 10 command

#If you don't have timeout installed, this is almost the same:
sh -c '(sleep 10; kill &quot;$$&quot;) &amp; command'

#The same as above, with muted duplicate messages:
sh -c '(sleep 10; kill &quot;$$&quot; 2&gt;/dev/null) &amp; command'
</code></pre>

I have a bash script that launches a child process that crashes (actually, hangs) from time to time and with no apparent reason (closed source, so there isn't much I can do about it). As a result, I would like to be able to launch this process for a given amount of time, and kill it if it did not return successfully after a given amount of time.

Is there a simple and robust way to achieve that using bash? 

P.S.: tell me if this question is better suited to serverfault or superuser.

How to kill a child process after a given timeout in Bash?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有一个bash脚本，它启动一个子进程，这个子进程会不时地崩溃(实际上是挂起)，而且没有明显的原因(关闭源代码，所以我对此无能为力)。因此，我希望能够在给定的时间量内启动此进程，如果在给定的时间量之后它没有成功返回，则终止它。有没有一种简单的和健壮的方法来使用bash来实现这一点？附言:告诉我这个问题是更适合serve...

问在Bash中，如何在给定的超时后杀除子进程？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Bash中，如何在给定的超时后杀除子进程？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Bash中，如何在给定的超时后杀除子进程？
EN