Linux shell使用trap命令优雅进行处理程序中断_Linux

来看一个常见的场景

假设你正在开发一个数据备份脚本。这个脚本需要执行以下操作：

创建临时工作目录
将数据复制到临时目录
压缩打包
清理临时文件

#!/bin/bash

work_dir="/tmp/backup_$(date +%y%m%d)"

echo "开始备份..."
mkdir -p "$work_dir"
echo "创建临时目录: $work_dir"

echo "复制文件中..."
cp -r /path/to/data "$work_dir/"
sleep 5  # 模拟耗时操作

echo "压缩打包..."
tar -czf backup.tar.gz "$work_dir"
sleep 3  # 模拟耗时操作

echo "清理临时文件..."
rm -rf "$work_dir"

echo "备份完成！"

如果我中断了脚本怎么办！

当我们运行这个脚本时，如果在执行过程中按下 ctrl+c 中断操作，会发生什么？

临时目录 $work_dir 将被遗留在系统中，因为清理步骤没有被执行。长期积累下来，这些未清理的临时文件会占用大量磁盘空间。

使用 trap 命令改善程序

这时，trap 命令就派上用场了。trap 可以捕获特定的信号并执行相应的处理函数。sigint（通常由 ctrl+c 触发）就是最常见的信号之一。

首先，我们定义一个中断处理函数：

on_interrupt() {
    echo -e "\n程序被中断！"
    echo "清理临时文件..."
    rm -rf "$work_dir"
    exit 1
}

然后，在脚本开头使用 trap 设置信号处理：

trap on_interrupt sigint

完整的改进版脚本如下：

#!/bin/bash

work_dir="/tmp/backup_$(date +%y%m%d)"

# 定义中断处理函数
on_interrupt() {
    echo -e "\n程序被中断！"
    echo "清理临时文件..."
    rm -rf "$work_dir"
    exit 1
}

# 设置 trap
trap on_interrupt sigint

echo "开始备份..."
mkdir -p "$work_dir"
echo "创建临时目录: $work_dir"

echo "复制文件中..."
cp -r /path/to/data "$work_dir/"
sleep 5  # 模拟耗时操作

echo "压缩打包..."
tar -czf backup.tar.gz "$work_dir"
sleep 3  # 模拟耗时操作

echo "清理临时文件..."
rm -rf "$work_dir"

echo "备份完成！"

trap 命令说明

trap 命令的基本语法是：

trap command signal

其中：

command 可以是函数名或直接的命令
signal 是要捕获的信号名称，如 sigint、sigterm 等

常见的信号包括：

sigint (2)：用户按下 ctrl+c
sigterm (15)：终止信号
exit：脚本退出时

你还可以同时捕获多个信号：

trap on_interrupt sigint sigterm

通过使用 trap 命令和 on_interrupt 函数，我们实现了：

优雅地处理程序中断
确保临时资源被正确清理
提供了友好的用户提示

这种模式不仅适用于备份脚本，还可以用在任何需要资源清理的脚本中，比如：

临时文件处理
数据库连接清理
锁文件删除
进程清理

扩展： trap 命令的高级应用

多信号处理

有时我们需要对不同的信号进行不同的处理。比如在一个数据处理脚本中：

#!/bin/bash

# 定义变量
data_file="data.txt"
temp_file="temp.txt"
log_file="process.log"

# 处理 ctrl+c
on_interrupt() {
    echo -e "\n收到 sigint，正在优雅关闭..."
    cleanup
    exit 1
}

# 处理 sigterm
on_terminate() {
    echo -e "\n收到 sigterm，保存进度后退出..."
    save_progress
    cleanup
    exit 1
}

# 处理正常退出
on_exit() {
    echo "程序正常结束，执行清理..."
    cleanup
}

# 清理函数
cleanup() {
    rm -f "$temp_file"
    echo "清理完成"
}

# 保存进度
save_progress() {
    echo "保存当前进度到 $log_file"
    echo "progress saved at $(date)" >> "$log_file"
}

# 设置多重信号处理
trap on_interrupt sigint
trap on_terminate sigterm
trap on_exit exit

# 主程序
echo "开始处理数据..."
while true; do
    echo "处理中..."
    sleep 1
done

临时禁用和恢复信号处理

有时我们需要临时禁用信号处理，比如在执行关键操作时：

#!/bin/bash

critical_operation() {
    # 临时禁用 ctrl+c
    trap '' sigint
    
    echo "执行关键操作，这段时间按 ctrl+c 无效..."
    sleep 5
    
    # 恢复信号处理
    trap on_interrupt sigint
    echo "关键操作完成，恢复正常信号处理"
}

on_interrupt() {
    echo -e "\n操作被中断！"
    exit 1
}

trap on_interrupt sigint

echo "开始执行..."
critical_operation
echo "继续其他操作..."

debug 信号与调试处理

debug 并不是中断信号，而是 bash 的一个特殊 trap 事件。它在执行每个命令之前触发，主要用于调试目的。让我们看一个更实用的例子：

#!/bin/bash

# 用于控制是否在错误处理函数中触发 debug trap
in_error_handler=0

# 定义调试处理函数
on_debug() {
    # 如果在错误处理函数中，跳过调试输出
    if ((in_error_handler)); then
        return
    fi
    # $1 是行号，$bash_command 是即将执行的命令
    echo "[debug] 行 $1: 准备执行 -> $bash_command"
}

# 错误处理函数
on_error() {
    local err=$?  # 立即保存错误码
    local line=$1
    local cmd=$2
    
    # 设置标志，防止在错误处理中触发 debug trap
    in_error_handler=1
    
    echo "[error] 行 $line 执行失败"
    echo "命令: $cmd"
    echo "错误码: $err"
    
    # 重置标志
    in_error_handler=0
}

# 启用调试跟踪
enable_debug() {
    # 启用 err trap
    set -e
    # -t 选项可以显示函数调用跟踪
    set -t
    # 设置 debug trap，传入行号参数
    trap 'on_debug ${lineno}' debug
    trap 'on_error ${lineno} "$bash_command"' err
}

# 关闭调试跟踪
disable_debug() {
    trap - debug
    trap - err
    set +e
    set +t
}

# 通过环境变量控制是否开启调试
if [[ "${enable_debug}" == "true" ]]; then
    enable_debug
fi

# 测试函数
test_function() {
    echo "执行测试函数"
    local result=$((2 + 2))
    echo "计算结果: $result"
    # 故意制造一个错误
    ls /nonexistent_directory
}

# 主程序
echo "开始执行..."
test_function
echo "尝试访问不存在的文件..."
cat nonexistent_file.txt

使用方式：

# 普通执行
./script.sh

# 开启调试模式执行
enable_debug=true ./script.sh

普通模式输出：

开始执行...
执行测试函数
计算结果: 4
ls: cannot access '/nonexistent_directory': no such file or directory
尝试访问不存在的文件...
cat: nonexistent_file.txt: no such file or directory

debug 模式输出：

[debug] 行 41: 准备执行 -> trap 'on_error ${lineno} "$bash_command"' err
[debug] 行 67: 准备执行 -> echo "开始执行..."
开始执行...
[debug] 行 68: 准备执行 -> test_function
[debug] 行 58: 准备执行 -> test_function
[debug] 行 59: 准备执行 -> echo "执行测试函数"
执行测试函数
[debug] 行 60: 准备执行 -> local result=$((2 + 2))
[debug] 行 61: 准备执行 -> echo "计算结果: $result"
计算结果: 4
[debug] 行 63: 准备执行 -> ls /nonexistent_directory
ls: cannot access '/nonexistent_directory': no such file or directory
[debug] 行 63: 准备执行 -> ls /nonexistent_directory
[debug] 行 17: 准备执行 -> ls /nonexistent_directory
[debug] 行 18: 准备执行 -> local err=$?
[debug] 行 19: 准备执行 -> local line=$1
[debug] 行 20: 准备执行 -> local cmd=$2
[debug] 行 23: 准备执行 -> in_error_handler=1
[error] 行 63 执行失败
命令: ls /nonexistent_directory
错误码: 2
[debug] 行 68: 准备执行 -> ls /nonexistent_directory
[debug] 行 17: 准备执行 -> ls /nonexistent_directory
[debug] 行 18: 准备执行 -> local err=$?
[debug] 行 19: 准备执行 -> local line=$1
[debug] 行 20: 准备执行 -> local cmd=$2
[debug] 行 23: 准备执行 -> in_error_handler=1
[error] 行 68 执行失败
命令: ls /nonexistent_directory
错误码: 2
[debug] 行 69: 准备执行 -> echo "尝试访问不存在的文件..."
尝试访问不存在的文件...
[debug] 行 70: 准备执行 -> cat nonexistent_file.txt
cat: nonexistent_file.txt: no such file or directory
[debug] 行 70: 准备执行 -> cat nonexistent_file.txt
[debug] 行 17: 准备执行 -> cat nonexistent_file.txt
[debug] 行 18: 准备执行 -> local err=$?
[debug] 行 19: 准备执行 -> local line=$1
[debug] 行 20: 准备执行 -> local cmd=$2
[debug] 行 23: 准备执行 -> in_error_handler=1
[error] 行 70 执行失败
命令: cat nonexistent_file.txt
错误码: 1

文件锁机制 trap vs flock

让我们比较 trap 和 flock 的锁机制：

使用 trap 的文件锁

#!/bin/bash

lock_file="/tmp/script.lock"
pid_file="/tmp/script.pid"

cleanup() {
    rm -f "$lock_file" "$pid_file"
    echo "清理锁文件和pid文件"
}

get_lock() {
    if [ -e "$lock_file" ]; then
        local pid
        pid=$(cat "$pid_file" 2>/dev/null)
        if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
            echo "另一个实例(pid: $pid)正在运行"
            exit 1
        fi
        # 如果进程不存在，清理旧的锁
        cleanup
    fi
    
    echo $$ > "$pid_file"
    touch "$lock_file"
    trap cleanup exit
}

使用 flock 的实现：

#!/bin/bash

lock_file="/tmp/script.lock"

(
    # 获取文件锁，等待最多5秒
    flock -w 5 200 || { echo "无法获取锁，另一个实例正在运行"; exit 1; }
    
    echo "获得锁，开始执行..."
    sleep 10
    echo "执行完成"
    
) 200>"$lock_file"

比较分析

可靠性
- flock 更可靠，它使用内核级文件锁
- trap 方式可能在极端情况下（如系统崩溃）留下孤立的锁文件
使用场景
- flock 适合要求严格的生产环境
- trap 方式适合简单的脚本和开发环境
推荐选择
- 推荐使用 flock，因为它：
  - 自动处理进程终止
  - 支持超时设置
  - 提供阻塞和非阻塞模式
  - 可靠性更高

事务的实现

#!/bin/bash

# 状态变量
transaction_active=false

# 动态改变信号处理
update_signal_handler() {
    if $transaction_active; then
        # 事务进行中，设置中断处理为提示并结束
        trap 'echo "事务进行中，已被强行中断..."; cleanup; exit 1' sigint
    else
        # 非事务状态，可以安全退出
        trap 'echo "正常退出..."; exit 0' sigint
    fi
}

# 清理函数
cleanup() {
    echo "执行清理操作..."
    # 这里添加实际的清理代码
}

# 模拟事务
start_transaction() {
    transaction_active=true
    update_signal_handler
    echo "事务开始"
    
    # 模拟事务操作
    echo "执行事务步骤 1/3"
    sleep 2
    echo "执行事务步骤 2/3"
    sleep 2
    echo "执行事务步骤 3/3"
    sleep 2
    
    transaction_active=false
    update_signal_handler
    echo "事务完成"
}

# 设置初始信号处理
update_signal_handler

# 主程序执行流程
echo "开始执行..."
start_transaction
echo "继续其他操作..."

执行流程说明：

脚本启动
- transaction_active 初始值为 false
- 首次调用 update_signal_handler，设置正常的中断处理
执行 start_transaction
- 设置 transaction_active 为 true
- 更新信号处理为事务保护模式
- 执行事务操作
- 完成后，设置 transaction_active 为 false
- 恢复正常的信号处理
信号处理行为
- 事务进行中收到 sigint：显示中断消息，执行清理，然后退出
- 非事务状态收到 sigint：直接安全退出