[1]   Running                 sleep 1000 &
[2]-  Stopped                 vim document.txt
[3]+  Running                 tail -f /var/log/syslog &

各部分的含义：

• [1]：作业编号，使用%1引用该作业
• +：当前作业（最近被放入后台或从前台暂停的作业）
• -：上一个作业
• Running：作业状态（运行中）
• Stopped：作业状态（已暂停）
• sleep 1000 &：作业命令

#!/bin/bash
# job_monitor.sh - 实时作业监控面板

MONITOR_INTERVAL=2  # 更新间隔（秒）

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m'  # No Color

# 清除屏幕并显示监控面板
show_monitor() {
    clear
    echo -e "${BLUE}=== 作业监控面板 ===${NC}"
    echo -e "时间: $(date '+%Y-%m-%d %H:%M:%S')"
    echo -e "用户: $(whoami)"
    echo -e "终端: $(tty)"
    echo

    # 获取作业信息
    local jobs_output=$(jobs -l)
    local running_count=$(jobs -r | wc -l)
    local stopped_count=$(jobs -s | wc -l)
    local total_count=$(jobs | wc -l)

    # 显示统计信息
    echo -e "${GREEN}运行中: ${running_count}${NC} | ${YELLOW}暂停中: ${stopped_count}${NC} | 总计: ${total_count}"
    echo "----------------------------------------"

    if [ -z "$jobs_output" ]; then
        echo "没有活动的作业"
    else
        # 高亮显示作业状态
        echo "$jobs_output" | while IFS= read -r line; do
            if [[ "$line" == *"Running"* ]]; then
                echo -e "${GREEN}$line${NC}"
            elif [[ "$line" == *"Stopped"* ]]; then
                echo -e "${YELLOW}$line${NC}"
            elif [[ "$line" == *"Done"* ]] || [[ "$line" == *"Exit"* ]] || [[ "$line" == *"Killed"* ]]; then
                echo -e "${RED}$line${NC}"
            else
                echo "$line"
            fi
        done
    fi

    echo
    echo "----------------------------------------"
    echo -e "${BLUE}系统资源:${NC}"

    # 显示系统资源使用
    if [ $total_count -gt 0 ]; then
        echo "作业CPU使用:"
        jobs -p | xargs -r ps -o pid,%cpu,cmd --no-headers -p 2>/dev/null | head -5

        echo
        echo "作业内存使用:"
        jobs -p | xargs -r ps -o pid,%mem,cmd --no-headers -p 2>/dev/null | head -5
    fi

    echo
    echo -e "${BLUE}快捷键:${NC}"
    echo -e "  ${GREEN}Enter${NC} - 刷新    ${YELLOW}q${NC} - 退出    ${RED}k${NC} - 杀死当前作业"
    echo -e "  ${BLUE}f${NC} - 前台运行  ${BLUE}b${NC} - 后台运行"
}

# 处理用户输入
handle_input() {
    read -t 0.1 -n 1 input  # 非阻塞读取单个字符
    if [ -n "$input" ]; then
        case "$input" in
            q)
                echo "退出监控..."
                exit 0
                ;;
            k)
                # 杀死当前作业（带+号的作业）
                current_job=$(jobs | grep '+ ' | head -1 | sed -n 's/\[\([0-9]\+\)\]+.*/\1/p')
                if [ -n "$current_job" ]; then
                    kill -9 %$current_job 2>/dev/null
                    echo "已杀死作业 $current_job"
                    sleep 1
                fi
                ;;
            f)
                # 将当前作业切换到前台
                current_job=$(jobs | grep '+ ' | head -1 | sed -n 's/\[\([0-9]\+\)\]+.*/\1/p')
                if [ -n "$current_job" ]; then
                    fg %$current_job
                    # 如果用户在前台按Ctrl+Z，会返回这里
                fi
                ;;
            b)
                # 将当前作业切换到后台
                current_job=$(jobs | grep '+ ' | head -1 | sed -n 's/\[\([0-9]\+\)\]+.*/\1/p')
                if [ -n "$current_job" ]; then
                    bg %$current_job 2>/dev/null
                    echo "作业 $current_job 已切换到后台"
                fi
                ;;
        esac
    fi
}

# 主监控循环
main() {
    echo "启动作业监控面板..."
    echo "按 q 键退出，其他快捷键见面板说明"
    sleep 2

    while true; do
        show_monitor
        handle_input
        sleep "$MONITOR_INTERVAL"
    done
}

# 启动监控
main

#!/bin/bash
# job_cleaner.sh - 作业自动清理系统

CLEANUP_INTERVAL=60  # 检查间隔（秒）
MAX_RUNTIME=3600     # 最大运行时间（秒），1小时
LOG_FILE="/var/log/job_cleaner.log"

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
}

# 清理完成或异常的作业
cleanup_jobs() {
    log "开始作业清理检查..."

    # 获取所有作业
    local jobs_info=$(jobs -l)

    if [ -z "$jobs_info" ]; then
        log "没有作业需要清理"
        return 0
    fi

    # 解析每行作业信息
    echo "$jobs_info" | while IFS= read -r line; do
        # 提取作业信息
        local job_num=$(echo "$line" | sed -n 's/\[\([0-9]\+\)\].*/\1/p')
        local job_pid=$(echo "$line" | awk '{print $2}')
        local job_status=$(echo "$line" | awk '{print $3}')
        local job_cmd=$(echo "$line" | cut -d' ' -f4-)

        log "检查作业 $job_num (PID: $job_pid, 状态: $job_status)"

        # 检查进程是否存在
        if ! ps -p "$job_pid" > /dev/null 2>&1; then
            log "  作业 $job_num 的进程 $job_pid 不存在，从作业表移除"
            # 使用 disown 或等待作业自动移除
            disown $job_pid 2>/dev/null || true
            continue
        fi

        # 检查运行时间
        local start_time=$(ps -o start= -p "$job_pid" 2>/dev/null)
        if [ -n "$start_time" ]; then
            # 计算运行时间（简化处理）
            local current_time=$(date +%s)
            local start_seconds=$(date -d "$start_time" +%s 2>/dev/null || echo $((current_time - 300)))
            local runtime=$((current_time - start_seconds))

            if [ $runtime -gt $MAX_RUNTIME ]; then
                log "  作业 $job_num 已运行 ${runtime}秒，超过最大运行时间 ${MAX_RUNTIME}秒"

                # 根据命令类型决定处理方式
                case "$job_cmd" in
                    *make*|*compile*|*build*)
                        log "    编译任务，允许继续运行"
                        ;;
                    *download*|*wget*|*curl*)
                        log "    下载任务，检查进度后决定"
                        # 可以添加下载进度检查逻辑
                        ;;
                    *)
                        log "    发送TERM信号终止作业"
                        kill -TERM "$job_pid" 2>/dev/null
                        sleep 2

                        # 如果进程还在，强制杀死
                        if ps -p "$job_pid" > /dev/null 2>&1; then
                            log "    进程仍在运行，发送KILL信号"
                            kill -KILL "$job_pid" 2>/dev/null
                        fi
                        ;;
                esac
            fi
        fi

        # 检查僵尸进程
        if [ "$job_status" = "Done" ] || [ "$job_status" = "Exit" ]; then
            log "  作业 $job_num 状态为 $job_status，进行清理"
            # 等待作业完全退出
            wait $job_pid 2>/dev/null
        fi
    done

    log "作业清理检查完成"
}

# 监控循环
monitor_loop() {
    log "作业自动清理系统启动"
    log "检查间隔: ${CLEANUP_INTERVAL}秒"
    log "最大运行时间: ${MAX_RUNTIME}秒"

    while true; do
        cleanup_jobs
        sleep "$CLEANUP_INTERVAL"
    done
}

# 启动监控（后台运行）
start_cleaner() {
    monitor_loop &
    CLEANER_PID=$!
    log "清理进程PID: $CLEANER_PID"
    echo $CLEANER_PID > /tmp/job_cleaner.pid
}

# 停止监控
stop_cleaner() {
    if [ -f /tmp/job_cleaner.pid ]; then
        local pid=$(cat /tmp/job_cleaner.pid)
        kill $pid 2>/dev/null
        rm -f /tmp/job_cleaner.pid
        log "清理系统已停止"
    else
        log "清理系统未运行"
    fi
}

# 查看状态
status_cleaner() {
    if [ -f /tmp/job_cleaner.pid ]; then
        local pid=$(cat /tmp/job_cleaner.pid)
        if ps -p $pid > /dev/null; then
            log "清理系统运行中 (PID: $pid)"
            tail -20 "$LOG_FILE"
        else
            log "清理进程已停止"
        fi
    else
        log "清理系统未运行"
    fi
}

# 主程序
case "$1" in
    start)
        start_cleaner
        ;;
    stop)
        stop_cleaner
        ;;
    status)
        status_cleaner
        ;;
    cleanup)
        cleanup_jobs
        ;;
    *)
        echo "用法: $0 {start|stop|status|cleanup}"
        exit 1
        ;;
esac

#!/bin/bash
# job_backup.sh - 作业备份和恢复系统

BACKUP_DIR="$HOME/.job_backups"
BACKUP_FILE="$BACKUP_DIR/jobs_$(date +%Y%m%d_%H%M%S).txt"
RESTORE_SCRIPT="$BACKUP_DIR/restore_$(date +%Y%m%d_%H%M%S).sh"

# 创建备份目录
mkdir -p "$BACKUP_DIR"

# 备份当前作业
backup_jobs() {
    echo "正在备份当前作业状态..."

    # 获取作业信息
    local jobs_info=$(jobs -l)

    if [ -z "$jobs_info" ]; then
        echo "没有作业需要备份"
        return 1
    fi

    # 保存原始作业信息
    echo "$jobs_info" > "$BACKUP_FILE"

    # 生成恢复脚本
    cat > "$RESTORE_SCRIPT" << EOF
#!/bin/bash
# 作业恢复脚本
# 生成时间: $(date)
# 原始作业信息:
$(echo "$jobs_info" | sed 's/^/# /')

echo "正在恢复作业..."

EOF

    # 解析每个作业，生成恢复命令
    echo "$jobs_info" | while IFS= read -r line; do
        local job_num=$(echo "$line" | sed -n 's/\[\([0-9]\+\)\].*/\1/p')
        local job_pid=$(echo "$line" | awk '{print $2}')
        local job_status=$(echo "$line" | awk '{print $3}')
        local job_cmd=$(echo "$line" | cut -d' ' -f4-)

        # 移除末尾的 & 符号（如果有）
        local clean_cmd=$(echo "$job_cmd" | sed 's/ &$//')

        # 根据状态生成不同的恢复命令
        case "$job_status" in
            Running)
                if [[ "$job_cmd" == *" &" ]]; then
                    # 后台运行作业
                    echo "# 恢复作业 $job_num: $clean_cmd" >> "$RESTORE_SCRIPT"
                    echo "$clean_cmd &" >> "$RESTORE_SCRIPT"
                    echo "echo '启动后台作业: $clean_cmd'" >> "$RESTORE_SCRIPT"
                else
                    # 应该不会出现这种情况，但处理一下
                    echo "# 注意: 作业 $job_num 显示为Running但没有 &" >> "$RESTORE_SCRIPT"
                fi
                ;;
            Stopped)
                # 暂停的作业，先启动再暂停
                echo "# 恢复暂停的作业 $job_num: $clean_cmd" >> "$RESTORE_SCRIPT"
                echo "$clean_cmd &" >> "$RESTORE_SCRIPT"
                echo "sleep 0.5" >> "$RESTORE_SCRIPT"
                echo "jobs -l | grep '$clean_cmd' | head -1 | sed -n 's/\\[\\([0-9]\\+\\)\\].*/\\1/p' | xargs -I {} kill -TSTP %{}" >> "$RESTORE_SCRIPT"
                echo "echo '恢复暂停作业: $clean_cmd'" >> "$RESTORE_SCRIPT"
                ;;
            *)
                echo "# 无法恢复状态为 $job_status 的作业: $clean_cmd" >> "$RESTORE_SCRIPT"
                ;;
        esac
    done

    # 添加完成提示
    cat >> "$RESTORE_SCRIPT" << EOF

echo "作业恢复完成"
echo "使用 'jobs -l' 查看当前作业状态"
EOF

    # 设置执行权限
    chmod +x "$RESTORE_SCRIPT"

    echo "备份完成!"
    echo "备份文件: $BACKUP_FILE"
    echo "恢复脚本: $RESTORE_SCRIPT"
    echo
    echo "要恢复作业，请执行:"
    echo "  source $RESTORE_SCRIPT"
    echo "或"
    echo "  bash $RESTORE_SCRIPT"
}

# 列出所有备份
list_backups() {
    echo "可用备份列表:"
    echo "序号 | 备份时间 | 备份文件"
    echo "----------------------------"

    local count=1
    for file in "$BACKUP_DIR"/jobs_*.txt; do
        if [ -f "$file" ]; then
            local timestamp=$(basename "$file" | sed 's/jobs_//;s/\.txt//')
            local display_time=$(echo "$timestamp" | sed 's/_/ /')
            printf "%-4s | %-19s | %s\n" "$count" "$display_time" "$file"
            count=$((count + 1))
        fi
    done
}

# 恢复指定备份
restore_backup() {
    local backup_num="$1"

    if [ -z "$backup_num" ]; then
        echo "请指定备份编号"
        list_backups
        return 1
    fi

    # 查找对应的备份文件
    local backup_files=("$BACKUP_DIR"/jobs_*.txt)
    if [ ${#backup_files[@]} -eq 0 ]; then
        echo "没有找到备份文件"
        return 1
    fi

    if [ "$backup_num" -gt 0 ] && [ "$backup_num" -le ${#backup_files[@]} ]; then
        local backup_file="${backup_files[$((backup_num-1))]}"
        local restore_script="${backup_file%.txt}.sh"

        if [ -f "$restore_script" ]; then
            echo "从备份恢复作业: $backup_file"
            echo "执行恢复脚本..."
            echo "----------------------------------------"
            bash "$restore_script"
        else
            echo "找不到对应的恢复脚本: $restore_script"
        fi
    else
        echo "无效的备份编号: $backup_num"
        list_backups
        return 1
    fi
}

# 清理旧备份
cleanup_backups() {
    local keep_days=7  # 保留最近7天的备份

    echo "清理超过 ${keep_days} 天的旧备份..."

    find "$BACKUP_DIR" -name "jobs_*.txt" -mtime +$keep_days -exec rm -f {} \;
    find "$BACKUP_DIR" -name "restore_*.sh" -mtime +$keep_days -exec rm -f {} \;

    echo "备份清理完成"
}

# 主程序
case "$1" in
    backup)
        backup_jobs
        ;;
    list)
        list_backups
        ;;
    restore)
        shift
        restore_backup "$@"
        ;;
    cleanup)
        cleanup_backups
        ;;
    *)
        echo "用法: $0 {backup|list|restore [编号]|cleanup}"
        echo
        echo "示例:"
        echo "  $0 backup           # 备份当前作业"
        echo "  $0 list             # 列出所有备份"
        echo "  $0 restore 1        # 恢复第1个备份"
        echo "  $0 cleanup          # 清理旧备份"
        exit 1
        ;;
esac