在99%的情况下，答案是不实现任何超时逻辑。超时逻辑在几乎任何情况下都是一个红色警告信号，表明有其他地方出了问题，应该予以修复。

有时你的进程会在n秒后挂起或中断吗?然后找出原因并解决这个问题。

顺便说一句，要正确地执行strager的解决方案，您需要使用等待“$SPID”而不是fg 1，因为在脚本中您没有作业控制(试图打开它是愚蠢的)。此外，fg 1依赖于这样一个事实，即您之前没有在脚本中启动任何其他作业，这是一个糟糕的假设。

我提出了一个问题，以保留shell上下文和允许超时，唯一的问题是它将停止脚本执行超时-但这是我提出的需求很好:

#!/usr/bin/env bash

safe_kill()
{
  ps aux | grep -v grep | grep $1 >/dev/null && kill ${2:-} $1
}

my_timeout()
{
  typeset _my_timeout _waiter_pid _return
  _my_timeout=$1
  echo "Timeout($_my_timeout) running: $*"
  shift
  (
    trap "return 0" USR1
    sleep $_my_timeout
    echo "Timeout($_my_timeout) reached for: $*"
    safe_kill $$
  ) &
  _waiter_pid=$!
  "$@" || _return=$?
  safe_kill $_waiter_pid -USR1
  echo "Timeout($_my_timeout) ran: $*"
  return ${_return:-0}
}

my_timeout 3 cd scripts
my_timeout 3 pwd
my_timeout 3 true  && echo true || echo false
my_timeout 3 false && echo true || echo false
my_timeout 3 sleep 10
my_timeout 3 pwd

输出:

Timeout(3) running: 3 cd scripts
Timeout(3) ran: cd scripts
Timeout(3) running: 3 pwd
/home/mpapis/projects/rvm/rvm/scripts
Timeout(3) ran: pwd
Timeout(3) running: 3 true
Timeout(3) ran: true
true
Timeout(3) running: 3 false
Timeout(3) ran: false
false
Timeout(3) running: 3 sleep 10
Timeout(3) reached for: sleep 10
Terminated

当然，我认为有一个目录叫做脚本

你完全可以用bash 4.3及以上版本来完成:

_timeout() { ( set +b; sleep "$1" & "${@:2}" & wait -n; r=$?; kill -9 `jobs -p`; exit $r; ) }

Example: _timeout 5 longrunning_command args Example: { _timeout 5 producer || echo KABOOM $?; } | consumer Example: producer | { _timeout 5 consumer1; consumer2; } Example: { while date; do sleep .3; done; } | _timeout 5 cat | less Needs Bash 4.3 for wait -n Gives 137 if the command was killed, else the return value of the command. Works for pipes. (You do not need to go foreground here!) Works with internal shell commands or functions, too. Runs in a subshell, so no variable export into the current shell, sorry.

如果你不需要返回代码，这可以变得更简单:

_timeout() { ( set +b; sleep "$1" & "${@:2}" & wait -n; kill -9 `jobs -p`; ) }

注:

严格来说你不需要;在;)，但是它使事情更加一致;}案例。set +b可能也可以不用，但小心为妙。 除了——forground(可能)，你可以实现所有的变量超时支持。——保存状态有点困难，不过。这是留给读者的练习;)

这个配方可以在壳中“自然地”使用(与flock fd一样自然):

(
set +b
sleep 20 &
{
YOUR SHELL CODE HERE
} &
wait -n
kill `jobs -p`
)

但是，如上所述，不能自然地以这种方式将环境变量重新导出到外壳中。

编辑:

真实世界的例子:超时__git_ps1以防它花费太长时间(对于像缓慢的SSHFS-Links这样的事情):

eval "__orig$(declare -f __git_ps1)" && __git_ps1() { ( git() { _timeout 0.3 /usr/bin/git "$@"; }; _timeout 0.3 __orig__git_ps1 "$@"; ) }

Edit2:错误修复。我注意到退出137是不需要的，同时使_timeout不可靠。

Edit3: git是一个顽固分子，所以它需要双重技巧才能令人满意地工作。

Edit4:在真实GIT示例的第一个_timeout中忘记了_。

简单的脚本，代码清晰。保存到/usr/local/bin/run目录:

#!/bin/bash

# run
# Run command with timeout $1 seconds.

# Timeout seconds
timeout_seconds="$1"
shift

# PID
pid=$$

# Start timeout
(
  sleep "$timeout_seconds"
  echo "Timed out after $timeout_seconds seconds"
  kill -- -$pid &>/dev/null
) &
timeout_pid=$!

# Run
"$@"

# Stop timeout
kill $timeout_pid &>/dev/null

超时一个运行时间过长的命令:

$ run 2 sleep 10
Timed out after 2 seconds
Terminated
$

对于完成的命令，立即结束:

$ run 10 sleep 2
$

我认为这正是你所要求的:

http://www.bashcookbook.com/bashinfo/source/bash-4.0/examples/scripts/timeout3

#!/bin/bash
#
# The Bash shell script executes a command with a time-out.
# Upon time-out expiration SIGTERM (15) is sent to the process. If the signal
# is blocked, then the subsequent SIGKILL (9) terminates it.
#
# Based on the Bash documentation example.

# Hello Chet,
# please find attached a "little easier"  :-)  to comprehend
# time-out example.  If you find it suitable, feel free to include
# anywhere: the very same logic as in the original examples/scripts, a
# little more transparent implementation to my taste.
#
# Dmitry V Golovashkin <Dmitry.Golovashkin@sas.com>

scriptName="${0##*/}"

declare -i DEFAULT_TIMEOUT=9
declare -i DEFAULT_INTERVAL=1
declare -i DEFAULT_DELAY=1

# Timeout.
declare -i timeout=DEFAULT_TIMEOUT
# Interval between checks if the process is still alive.
declare -i interval=DEFAULT_INTERVAL
# Delay between posting the SIGTERM signal and destroying the process by SIGKILL.
declare -i delay=DEFAULT_DELAY

function printUsage() {
    cat <<EOF

Synopsis
    $scriptName [-t timeout] [-i interval] [-d delay] command
    Execute a command with a time-out.
    Upon time-out expiration SIGTERM (15) is sent to the process. If SIGTERM
    signal is blocked, then the subsequent SIGKILL (9) terminates it.

    -t timeout
        Number of seconds to wait for command completion.
        Default value: $DEFAULT_TIMEOUT seconds.

    -i interval
        Interval between checks if the process is still alive.
        Positive integer, default value: $DEFAULT_INTERVAL seconds.

    -d delay
        Delay between posting the SIGTERM signal and destroying the
        process by SIGKILL. Default value: $DEFAULT_DELAY seconds.

As of today, Bash does not support floating point arithmetic (sleep does),
therefore all delay/time values must be integers.
EOF
}

# Options.
while getopts ":t:i:d:" option; do
    case "$option" in
        t) timeout=$OPTARG ;;
        i) interval=$OPTARG ;;
        d) delay=$OPTARG ;;
        *) printUsage; exit 1 ;;
    esac
done
shift $((OPTIND - 1))

# $# should be at least 1 (the command to execute), however it may be strictly
# greater than 1 if the command itself has options.
if (($# == 0 || interval <= 0)); then
    printUsage
    exit 1
fi

# kill -0 pid   Exit code indicates if a signal may be sent to $pid process.
(
    ((t = timeout))

    while ((t > 0)); do
        sleep $interval
        kill -0 $$ || exit 0
        ((t -= interval))
    done

    # Be nice, post SIGTERM first.
    # The 'exit 0' below will be executed if any preceeding command fails.
    kill -s SIGTERM $$ && kill -0 $$ || exit 0
    sleep $delay
    kill -s SIGKILL $$
) 2> /dev/null &

exec "$@"

我的问题可能有点不同:我在远程机器上通过ssh启动一个命令，如果命令挂起，我想杀死shell和子程序。

我现在使用以下方法:

ssh server '( sleep 60 && kill -9 0 ) 2>/dev/null & my_command; RC=$? ; sleep 1 ; pkill -P $! ; exit $RC'

这样，当有超时时，命令返回255，如果成功，则返回命令的returncode

请注意，从ssh会话中杀死进程的处理方式与交互式shell不同。但是您也可以使用-t选项为ssh分配一个伪终端，这样它就像一个交互式shell