Linux fg命令

有几种方法可以精确切换到特定的后台作业：

# 方法1: 使用作业号（最精确）
# 先查看所有作业及其编号
jobs -l
# [1]   12345 Running                 sleep 1000 &
# [2]-  12346 Stopped                 vim file.txt
# [3]+  12347 Running                 tail -f log.txt &

# 切换到作业2
fg %2

# 方法2: 使用进程ID（需要额外步骤）
# 查找特定进程的作业号
find_job_by_pid() {
    local pid="$1"
    local job_info=$(jobs -l | grep " $pid ")

    if [ -n "$job_info" ]; then
        local job_num=$(echo "$job_info" | sed -n 's/\[\([0-9]\+\)\].*/\1/p')
        echo "找到作业: $job_num (PID: $pid)"
        fg %$job_num
    else
        echo "未找到PID为 $pid 的作业"
    fi
}

# 使用示例
find_job_by_pid 12346

# 方法3: 使用命令名匹配
# 切换到以特定字符串开头的作业
fg %sleep     # 切换到以sleep开头的作业
fg %vim       # 切换到以vim开头的作业

# 切换到包含特定字符串的作业
fg %?file     # 切换到包含file的作业
fg %?log      # 切换到包含log的作业

# 方法4: 使用作业状态过滤
# 只切换到运行中的作业
fg_running() {
    local running_jobs=$(jobs -r)

    if [ -z "$running_jobs" ]; then
        echo "没有运行中的作业"
        return 1
    fi

    # 如果有多个运行中的作业，选择第一个
    local job_num=$(echo "$running_jobs" | head -1 | sed -n 's/\[\([0-9]\+\)\].*/\1/p')
    fg %$job_num
}

# 只切换到暂停的作业
fg_stopped() {
    local stopped_jobs=$(jobs -s)

    if [ -z "$stopped_jobs" ]; then
        echo "没有暂停的作业"
        return 1
    fi

    local job_num=$(echo "$stopped_jobs" | head -1 | sed -n 's/\[\([0-9]\+\)\].*/\1/p')
    fg %$job_num
}

# 方法5: 交互式选择
interactive_fg() {
    # 获取作业列表
    local job_list=$(jobs -l)

    if [ -z "$job_list" ]; then
        echo "没有可用的作业"
        return 1
    fi

    # 显示作业菜单
    echo "请选择要切换到前台的作业:"
    echo "$job_list" | cat -n

    # 读取用户选择
    read -p "请输入编号: " choice

    # 提取作业号
    local job_line=$(echo "$job_list" | sed -n "${choice}p")
    local job_num=$(echo "$job_line" | sed -n 's/\[\([0-9]\+\)\].*/\1/p')

    if [ -n "$job_num" ]; then
        fg %$job_num
    else
        echo "无效的选择"
    fi
}

# 方法6: 最近使用的作业
# fg（无参数）切换到当前作业（最近使用的作业）
fg
# 或
fg %+
fg %%

# 上一个作业
fg %-

脚本中默认禁用作业控制，需要显式启用：

#!/bin/bash
# fg_in_script.sh

# 方法1: 启用作业控制
set -m  # 启用作业控制
# 或
set -o monitor

echo "作业控制已启用"

# 启动后台作业
sleep 100 &
JOB1_PID=$!
echo "后台作业1 PID: $JOB1_PID"

sleep 200 &
JOB2_PID=$!
echo "后台作业2 PID: $JOB2_PID"

# 查看作业
jobs -l

# 将作业1切换到前台
fg %1
# 注意：这会使脚本暂停，直到作业1完成或再次被暂停

# 如果作业在前台运行，脚本会阻塞在这里
# 可以按Ctrl+Z暂停，然后脚本继续执行

echo "脚本继续执行..."

# 方法2: 使用子Shell启用作业控制
(
    echo "在子Shell中启用作业控制"
    set -m

    # 启动作业
    sleep 300 &

    # 查看作业
    jobs -l

    # 切换到前台
    fg %1

    echo "子Shell中的作业完成"
)

# 方法3: 使用协进程（coproc）
echo "使用协进程:"
coproc MYPROC {
    echo "协进程开始"
    sleep 5
    echo "协进程结束"
}

# 获取协进程信息
echo "协进程PID: ${MYPROC_PID}"
echo "输入FD: ${MYPROC[0]}"
echo "输出FD: ${MYPROC[1]}"

# 读取协进程输出
read -r output <&"${MYPROC[0]}"
echo "协进程输出: $output"

# 方法4: 使用命名管道控制
CONTROL_PIPE="/tmp/control_pipe.$$"
mkfifo "$CONTROL_PIPE"

# 启动受控进程
(
    echo "受控进程启动"

    # 从管道读取控制命令
    while read -r cmd; do
        case "$cmd" in
            "fg")
                echo "切换到前台模式"
                # 实际的前台处理逻辑
                ;;
            "bg")
                echo "切换到后台模式"
                ;;
            "pause")
                echo "暂停"
                ;;
            "resume")
                echo "恢复"
                ;;
            "exit")
                echo "退出"
                break
                ;;
        esac
    done < "$CONTROL_PIPE"
) &
CONTROLLED_PID=$!

# 发送控制命令
echo "fg" > "$CONTROL_PIPE"
sleep 1
echo "pause" > "$CONTROL_PIPE"
sleep 1
echo "resume" > "$CONTROL_PIPE"
sleep 1
echo "exit" > "$CONTROL_PIPE"

# 等待进程结束
wait $CONTROLLED_PID

# 清理
rm -f "$CONTROL_PIPE"

# 方法5: 使用文件锁和状态文件
STATE_FILE="/tmp/job_state.$$"

# 启动工作进程
(
    # 初始化状态
    echo "running" > "$STATE_FILE"

    trap 'echo "paused" > "$STATE_FILE"; exit 0' SIGTSTP
    trap 'echo "terminated" > "$STATE_FILE"; exit 0' SIGINT

    echo "工作进程运行中..."
    sleep 10
    echo "工作进程完成"
) &
WORKER_PID=$!

# 控制循环
while true; do
    # 读取状态
    state=$(cat "$STATE_FILE" 2>/dev/null || echo "unknown")

    case "$state" in
        "running")
            echo "工作进程运行中"
            ;;
        "paused")
            echo "工作进程已暂停"
            read -p "恢复执行? (y/n): " choice
            if [[ "$choice" == "y" ]]; then
                kill -CONT $WORKER_PID
                echo "running" > "$STATE_FILE"
            fi
            ;;
        "terminated")
            echo "工作进程已终止"
            break
            ;;
        *)
            echo "未知状态: $state"
            break
            ;;
    esac

    sleep 2
done

rm -f "$STATE_FILE"

脚本中使用fg的注意事项：

• 作业控制会使脚本行为复杂化
• 生产环境脚本通常避免使用作业控制
• 考虑使用更专业的进程管理工具
• 确保正确处理信号和清理资源
• 注意不同Shell的兼容性问题

fg和Ctrl+Z组合使用可以实现强大的作业控制：

# 技巧1: 快速任务切换
# 启动任务A
vim file1.txt

# 按Ctrl+Z暂停
# [1]+  Stopped                 vim file1.txt

# 启动任务B
python script.py

# 按Ctrl+Z暂停
# [2]+  Stopped                 python script.py

# 快速切换回任务A
fg %1
# 或 fg %vim

# 技巧2: 临时中断处理
# 长时间运行的任务
./long_running_task.sh

# 运行中需要临时处理其他事情
# 按Ctrl+Z暂停
# [1]+  Stopped                 ./long_running_task.sh

# 处理临时任务
quick_check.sh

# 返回原任务
fg
# 或 fg %1

# 技巧3: 多任务轮转
# 启动多个任务
task1.sh &
task2.sh &
task3.sh &

# 轮流切换到前台查看状态
fg %1
# 查看任务1，按Ctrl+Z暂停

fg %2
# 查看任务2，按Ctrl+Z暂停

fg %3
# 查看任务3，按Ctrl+Z暂停

# 技巧4: 安全保存状态
# 重要编辑任务
vim important_doc.txt

# 临时需要离开，安全保存
# 在vim中按Ctrl+Z（保存文件并暂停vim）
# [1]+  Stopped                 vim important_doc.txt

# 可以安全关闭终端，稍后恢复
# 重新打开终端后，如果有作业会提示
# 有停止的作业

# 恢复编辑
fg
# 或 vim important_doc.txt

# 技巧5: 调试循环
debug_cycle() {
    # 启动被调试的程序
    ./buggy_program &
    DEBUG_PID=$!

    while true; do
        # 等待程序运行
        sleep 2

        # 暂停程序进行调试
        kill -TSTP $DEBUG_PID

        # 交互调试
        echo "程序已暂停，进行调试..."
        read -p "调试命令 (c=继续, q=退出): " cmd

        case "$cmd" in
            c)
                # 继续执行
                kill -CONT $DEBUG_PID
                ;;
            q)
                # 退出调试
                kill -TERM $DEBUG_PID
                break
                ;;
            *)
                echo "未知命令"
                ;;
        esac
    done
}

# 技巧6: 资源监控模式
resource_monitor() {
    # 启动资源密集型任务
    ./resource_hungry_task.sh &
    TASK_PID=$!

    # 监控循环
    while kill -0 $TASK_PID 2>/dev/null; do
        # 暂停任务进行检查
        kill -TSTP $TASK_PID

        # 检查资源使用
        echo "=== 资源检查 ==="
        ps -p $TASK_PID -o pid,%cpu,%mem,cmd
        echo

        # 等待用户决定
        read -p "继续执行? (y/n/p=暂停): " choice

        case "$choice" in
            y)
                # 继续执行
                kill -CONT $TASK_PID
                sleep 5  # 运行5秒后再检查
                ;;
            n)
                # 终止任务
                kill -TERM $TASK_PID
                break
                ;;
            p)
                # 保持暂停状态
                echo "任务保持暂停状态"
                break
                ;;
        esac
    done
}

# 技巧7: 批量作业控制
batch_control() {
    # 启动一批作业
    for i in {1..5}; do
        ./job_$i.sh &
        echo "作业 $i 启动: $!"
    done

    # 批量控制
    while true; do
        echo "当前作业状态:"
        jobs -l

        echo
        echo "控制选项:"
        echo "1. 将所有作业切换到前台"
        echo "2. 将所有作业暂停"
        echo "3. 恢复所有暂停的作业"
        echo "4. 终止所有作业"
        echo "5. 退出"

        read -p "选择: " option

        case "$option" in
            1)
                # 将所有作业依次切换到前台
                for job in $(jobs -p); do
                    fg %$(jobs -l | grep " $job " | sed 's/\[\([0-9]\+\).*/\1/')
                    # 按Ctrl+Z暂停当前作业，继续下一个
                done
                ;;
            2)
                # 暂停所有运行中的作业
                for job in $(jobs -rp); do
                    kill -TSTP $job
                done
                ;;
            3)
                # 恢复所有暂停的作业
                for job in $(jobs -sp); do
                    kill -CONT $job
                done
                ;;
            4)
                # 终止所有作业
                for job in $(jobs -p); do
                    kill -TERM $job
                done
                break
                ;;
            5)
                break
                ;;
        esac
    done
}