kill 命令详解#

# 终止进程
kill 1234

# 强制终止进程
kill -9 1234

# 查看可用信号
kill -l

# 发送特定信号
kill -TERM 1234

# 终止进程
kill 1234

# 强制终止进程
kill -9 1234

# 查看进程信息
ps -p 1234

# 发送挂起信号
kill -HUP 1234

# 查看所有可用信号
kill -l

# 查看特定信号编号
kill -l TERM

# 发送中断信号
kill -INT 1234

# 发送退出信号
kill -QUIT 1234

# 发送停止信号
kill -STOP 1234

# 发送继续信号
kill -CONT 1234

# 正常终止进程
kill 1234

# 强制终止进程
kill -9 1234

# 终止进程组
kill -1234

# 终止所有同名进程
killall nginx

# 强制终止所有同名进程
killall -9 nginx

# 暂停进程
kill -STOP 1234

# 恢复进程
kill -CONT 1234

# 重新加载配置
kill -HUP 1234

# 发送用户定义信号
kill -USR1 1234
kill -USR2 1234

# 终止特定用户的所有进程
kill -u username

# 终止特定进程名的所有进程
pkill nginx

# 终止匹配模式的进程
pkill -f "python script.py"

# 查找并终止进程
pgrep nginx | xargs kill

# 终止多个进程
kill 1234 5678 9012

# 发送 SIGUSR1
kill -USR1 1234

# 发送 SIGUSR2
kill -USR2 1234

# 发送 SIGALRM
kill -ALRM 1234

# 发送 SIGPIPE
kill -PIPE 1234

# 发送 SIGCHLD
kill -CHLD 1234

#!/bin/bash
# 信号处理示例

# 定义信号处理函数
handle_signal() {
    echo "Received signal: $1"
    exit 0
}

# 注册信号处理函数
trap handle_signal SIGTERM SIGINT

# 主循环
while true; do
    echo "Running..."
    sleep 1
done

#!/bin/bash
# 进程管理脚本

PROCESS_NAME=$1
SIGNAL=${2:-TERM}

# 查找并终止进程
find_and_kill() {
    local process_name=$1
    local signal=$2
    
    local pids=$(pgrep "$process_name")
    
    if [ -z "$pids" ]; then
        echo "No processes found matching: $process_name"
        return 1
    fi
    
    echo "Found processes:"
    ps -p $pids -o pid,cmd
    
    read -p "Kill these processes? (y/n) " -n 1 -r
    echo
    
    if [[ $REPLY =~ ^[Yy]$ ]]; then
        kill -$signal $pids
        
        if [ $? -eq 0 ]; then
            echo "Processes terminated successfully"
        else
            echo "Failed to terminate processes"
            return 1
        fi
    fi
}

# 强制终止进程
force_kill() {
    local process_name=$1
    
    local pids=$(pgrep "$process_name")
    
    if [ -n "$pids" ]; then
        echo "Force killing processes: $process_name"
        kill -9 $pids
        
        if [ $? -eq 0 ]; then
            echo "Processes force killed successfully"
        else
            echo "Failed to force kill processes"
            return 1
        fi
    else
        echo "No processes found matching: $process_name"
        return 1
    fi
}

# 查找僵尸进程
find_zombie_processes() {
    echo "Finding zombie processes..."
    
    local zombie_pids=$(ps -eo stat,pid | grep "^Z" | awk '{print $2}')
    
    if [ -n "$zombie_pids" ]; then
        echo "Zombie processes found:"
        ps -p $zombie_pids -o pid,ppid,cmd
        
        read -p "Kill zombie processes? (y/n) " -n 1 -r
        echo
        
        if [[ $REPLY =~ ^[Yy]$ ]]; then
            # 僵尸进程需要杀死父进程
            local parent_pids=$(ps -p $zombie_pids -o ppid --no-headers | sort -u)
            
            if [ -n "$parent_pids" ]; then
                echo "Killing parent processes: $parent_pids"
                kill -9 $parent_pids
            fi
        fi
    else
        echo "No zombie processes found"
    fi
}

# 主函数
main() {
    case "$1" in
        find)
            find_and_kill "$2" "$3"
            ;;
        force)
            force_kill "$2"
            ;;
        zombie)
            find_zombie_processes
            ;;
        *)
            echo "Usage: $0 {find|force|zombie}"
            exit 1
            ;;
    esac
}

main "$@"

#!/bin/bash
# 进程监控和自动终止脚本

PROCESS_NAME=$1
MAX_CPU=$2
MAX_MEMORY=$3
LOG_FILE="process_monitor.log"

# 监控进程资源使用
monitor_process() {
    local process_name=$1
    local max_cpu=$2
    local max_memory=$3
    
    while true; do
        local pid=$(pgrep -o "$process_name")
        
        if [ -n "$pid" ]; then
            local cpu_usage=$(ps -p $pid -o %cpu --no-headers)
            local mem_usage=$(ps -p $pid -o %mem --no-headers)
            
            echo "$(date '+%Y-%m-%d %H:%M:%S') - PID: $pid, CPU: ${cpu_usage}%, MEM: ${mem_usage}%" >> $LOG_FILE
            
            if (( $(echo "$cpu_usage > $max_cpu" | bc -l) )); then
                echo "ALERT: High CPU usage: ${cpu_usage}%" >> $LOG_FILE
                kill -TERM $pid
                sleep 5
                
                if ps -p $pid > /dev/null 2>&1; then
                    echo "Force killing process..." >> $LOG_FILE
                    kill -9 $pid
                fi
            fi
            
            if (( $(echo "$mem_usage > $max_memory" | bc -l) )); then
                echo "ALERT: High memory usage: ${mem_usage}%" >> $LOG_FILE
                kill -TERM $pid
                sleep 5
                
                if ps -p $pid > /dev/null 2>&1; then
                    echo "Force killing process..." >> $LOG_FILE
                    kill -9 $pid
                fi
            fi
        fi
        
        sleep 60
    done
}

# 主函数
main() {
    if [ -z "$PROCESS_NAME" ]; then
        echo "Usage: $0 <process_name> <max_cpu> <max_memory>"
        exit 1
    fi
    
    monitor_process $PROCESS_NAME $MAX_CPU $MAX_MEMORY
}

main "$@"

#!/bin/bash
# 信号发送工具

# 发送信号到进程
send_signal() {
    local pid=$1
    local signal=$2
    
    if ! ps -p $pid > /dev/null 2>&1; then
        echo "Process $pid not found"
        return 1
    fi
    
    echo "Sending $signal to process $pid..."
    kill -$signal $pid
    
    if [ $? -eq 0 ]; then
        echo "Signal sent successfully"
        
        # 等待进程响应
        sleep 2
        
        if ps -p $pid > /dev/null 2>&1; then
            echo "Process still running"
        else
            echo "Process terminated"
        fi
    else
        echo "Failed to send signal"
        return 1
    fi
}

# 发送信号到进程组
send_signal_to_group() {
    local pgid=$1
    local signal=$2
    
    echo "Sending $signal to process group $pgid..."
    kill -$signal -$pgid
    
    if [ $? -eq 0 ]; then
        echo "Signal sent successfully to process group"
    else
        echo "Failed to send signal to process group"
        return 1
    fi
}

# 发送信号到所有用户进程
send_signal_to_user() {
    local username=$1
    local signal=$2
    
    echo "Sending $signal to all processes of user $username..."
    kill -$signal -u $username
    
    if [ $? -eq 0 ]; then
        echo "Signal sent successfully to user processes"
    else
        echo "Failed to send signal to user processes"
        return 1
    fi
}

# 批量发送信号
batch_send_signal() {
    local pattern=$1
    local signal=$2
    
    local pids=$(pgrep "$pattern")
    
    if [ -z "$pids" ]; then
        echo "No processes found matching: $pattern"
        return 1
    fi
    
    echo "Found processes: $pids"
    echo "Sending $signal to all matching processes..."
    
    for pid in $pids; do
        kill -$signal $pid
        
        if [ $? -eq 0 ]; then
            echo "✓ Signal sent to $pid"
        else
            echo "✗ Failed to send signal to $pid"
        fi
    done
}

# 主函数
main() {
    case "$1" in
        send)
            send_signal "$2" "$3"
            ;;
        group)
            send_signal_to_group "$2" "$3"
            ;;
        user)
            send_signal_to_user "$2" "$3"
            ;;
        batch)
            batch_send_signal "$2" "$3"
            ;;
        *)
            echo "Usage: $0 {send|group|user|batch}"
            exit 1
            ;;
    esac
}

main "$@"

#!/bin/bash
# 企业级进程管理系统

CONFIG_FILE="/etc/process_manager/config.conf"
LOG_DIR="/var/log/process_manager"
STATE_DIR="/var/run/process_manager"

mkdir -p $LOG_DIR $STATE_DIR

# 加载配置
source $CONFIG_FILE

# 初始化进程监控
init_process_monitor() {
    local process_name=$1
    local state_file="$STATE_DIR/${process_name}.state"
    
    local pid=$(pgrep -o "$process_name")
    
    if [ -n "$pid" ]; then
        echo "$pid" > $state_file
        log_message "$process_name initialized with PID: $pid"
    else
        echo "0" > $state_file
        log_message "$process_name not found"
    fi
}

# 监控进程状态
monitor_process() {
    local process_name=$1
    local state_file="$STATE_DIR/${process_name}.state"
    
    while true; do
        local current_pid=$(pgrep -o "$process_name")
        local saved_pid=$(cat $state_file)
        
        if [ "$current_pid" != "$saved_pid" ]; then
            log_message "Process $process_name PID changed: $saved_pid -> $current_pid"
            
            if [ -n "$current_pid" ]; then
                echo "$current_pid" > $state_file
                log_message "$process_name is now running with PID: $current_pid"
            else
                log_message "ALERT: Process $process_name stopped"
                
                # 尝试重启
                if [ "$AUTO_RESTART" = "true" ]; then
                    log_message "Attempting to restart $process_name..."
                    systemctl restart $process_name
                    
                    if [ $? -eq 0 ]; then
                        local new_pid=$(pgrep -o "$process_name")
                        echo "$new_pid" > $state_file
                        log_message "$process_name restarted with PID: $new_pid"
                    else
                        log_message "ERROR: Failed to restart $process_name"
                        send_alert "Process $process_name failed to restart"
                    fi
                fi
            fi
        fi
        
        # 检查进程资源使用
        if [ -n "$current_pid" ]; then
            check_process_resources $process_name $current_pid
        fi
        
        sleep $MONITOR_INTERVAL
    done
}

# 检查进程资源使用
check_process_resources() {
    local process_name=$1
    local pid=$2
    
    local cpu_usage=$(ps -p $pid -o %cpu --no-headers)
    local mem_usage=$(ps -p $pid -o %mem --no-headers)
    
    if (( $(echo "$cpu_usage > $CPU_THRESHOLD" | bc -l) )); then
        log_message "ALERT: $process_name CPU usage high: ${cpu_usage}%"
        
        if [ "$AUTO_KILL" = "true" ]; then
            log_message "Auto-killing $process_name..."
            kill -9 $pid
        fi
    fi
    
    if (( $(echo "$mem_usage > $MEMORY_THRESHOLD" | bc -l) )); then
        log_message "ALERT: $process_name memory usage high: ${mem_usage}%"
        
        if [ "$AUTO_KILL" = "true" ]; then
            log_message "Auto-killing $process_name..."
            kill -9 $pid
        fi
    fi
}

# 记录日志
log_message() {
    local message=$1
    local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
    echo "[$timestamp] $message" >> $LOG_DIR/manager.log
}

# 发送告警
send_alert() {
    local message=$1
    
    if [ "$ENABLE_EMAIL_ALERTS" = "true" ]; then
        echo "$message" | mail -s "Process Manager Alert" $ALERT_EMAIL
    fi
    
    if [ "$ENABLE_SLACK_ALERTS" = "true" ]; then
        curl -X POST -H 'Content-type: application/json' --data "{\"text\":\"$message\"}" $SLACK_WEBHOOK
    fi
}

# 生成监控报告
generate_monitor_report() {
    local report_file="$LOG_DIR/monitor_report_$(date +%Y%m%d).txt"
    
    echo "Process Monitor Report - $(date +%Y-%m-%d)" > $report_file
    echo "=========================" >> $report_file
    echo "" >> $report_file
    
    for process_name in "${MANAGED_PROCESSES[@]}"; do
        echo "=== $process_name ===" >> $report_file
        
        local pid=$(pgrep -o "$process_name")
        if [ -n "$pid" ]; then
            ps -p $pid -f >> $report_file
        else
            echo "Process not running" >> $report_file
        fi
        
        echo "" >> $report_file
    done
    
    log_message "Monitor report generated: $report_file"
}

# 主程序
main() {
    log_message "Process Manager started"
    
    for process_name in "${MANAGED_PROCESSES[@]}"; do
        init_process_monitor $process_name
        monitor_process $process_name &
    done
    
    while true; do
        if [ $(date +%H) -eq 0 ] && [ $(date +%M) -eq 0 ]; then
            generate_monitor_report
        fi
        
        sleep 60
    done
}

main

#!/bin/bash
# 智能进程调度系统

CONFIG_FILE="/etc/process_scheduler/config.conf"
LOG_FILE="/var/log/process_scheduler/scheduler.log"

mkdir -p $(dirname $LOG_FILE)

# 加载配置
source $CONFIG_FILE

# 检查系统负载
check_system_load() {
    local load=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | cut -d',' -f1)
    local max_load=${MAX_LOAD:-2.0}
    
    if (( $(echo "$load < $max_load" | bc -l) )); then
        return 0
    else
        return 1
    fi
}

# 检查内存使用
check_memory_usage() {
    local memory_usage=$(free | awk '/Mem:/ {print $3/$2 * 100.0}')
    local max_memory=${MAX_MEMORY:-80}
    
    if (( $(echo "$memory_usage < $max_memory" | bc -l) )); then
        return 0
    else
        return 1
    fi
}

# 检查时间窗口
check_time_window() {
    local current_hour=$(date +%H)
    local start_hour=${START_HOUR:-0}
    local end_hour=${END_HOUR:-6}
    
    if [ $current_hour -ge $start_hour ] && [ $current_hour -lt $end_hour ]; then
        return 0
    else
        return 1
    fi
}

# 调度进程操作
schedule_process_operation() {
    local process_name=$1
    local operation=$2
    
    echo "Scheduling $operation for $process_name"
    
    # 检查系统条件
    if ! check_system_load; then
        echo "System load too high, postponing $operation"
        return 1
    fi
    
    if ! check_memory_usage; then
        echo "Memory usage too high, postponing $operation"
        return 1
    fi
    
    if ! check_time_window; then
        echo "Outside allowed time window, postponing $operation"
        return 1
    fi
    
    # 执行操作
    echo "Executing $operation for $process_name"
    
    case "$operation" in
        start)
            systemctl start $process_name
            ;;
        stop)
            systemctl stop $process_name
            ;;
        restart)
            systemctl restart $process_name
            ;;
        kill)
            local pid=$(pgrep -o "$process_name")
            if [ -n "$pid" ]; then
                kill -TERM $pid
                sleep 5
                
                if ps -p $pid > /dev/null 2>&1; then
                    kill -9 $pid
                fi
            fi
            ;;
        *)
            echo "Unknown operation: $operation"
            return 1
            ;;
    esac
    
    if [ $? -eq 0 ]; then
        echo "✓ $operation completed for $process_name"
        return 0
    else
        echo "✗ $operation failed for $process_name"
        return 1
    fi
}

# 主调度循环
main_scheduler() {
    log_message "Process Scheduler started"
    
    while true; do
        # 从配置文件读取进程操作
        while IFS='|' read -r process_name operation; do
            if [ -n "$process_name" ] && [[ ! $process_name =~ ^# ]]; then
                schedule_process_operation "$process_name" "$operation"
            fi
        done < "$CONFIG_FILE"
        
        # 等待下次检查
        sleep $SCHEDULER_INTERVAL
    done
}

# 单次执行模式
single_run() {
    while IFS='|' read -r process_name operation; do
        if [ -n "$process_name" ] && [[ ! $process_name =~ ^# ]]; then
            schedule_process_operation "$process_name" "$operation"
        fi
    done < "$CONFIG_FILE"
}

# 记录日志
log_message() {
    local message=$1
    local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
    echo "[$timestamp] $message" >> $LOG_FILE
}

# 主函数
main() {
    case "$1" in
        start)
            main_scheduler
            ;;
        run)
            single_run
            ;;
        *)
            echo "Usage: $0 {start|run}"
            exit 1
            ;;
    esac
}

main "$@"

#!/bin/bash
# 进程安全管理系统

AUDIT_LOG="/var/log/process_security/audit.log"
ALERT_LOG="/var/log/process_security/alerts.log"
WHITELIST="/etc/process_security/whitelist.conf"

mkdir -p $(dirname $AUDIT_LOG) $(dirname $ALERT_LOG)

# 审计进程终止
audit_process_termination() {
    local pid=$1
    local signal=$2
    local user=$(whoami)
    
    echo "$(date '+%Y-%m-%d %H:%M:%S') - User: $user, PID: $pid, Signal: $signal" >> $AUDIT_LOG
    
    # 检查是否为关键进程
    local process_name=$(ps -p $pid -o comm --no-headers)
    
    if [ -f "$WHITELIST" ]; then
        if ! grep -q "$process_name" $WHITELIST; then
            echo "ALERT: Non-whitelisted process terminated: $process_name (PID: $pid)" >> $ALERT_LOG
            send_alert "Non-whitelisted process terminated: $process_name (PID: $pid)"
        fi
    fi
}

# 检测异常终止
detect_abnormal_termination() {
    local pid=$1
    local signal=$2
    
    case "$signal" in
        SIGKILL|9)
            echo "ALERT: Process $pid was force killed" >> $ALERT_LOG
            send_alert "Process $pid was force killed"
            ;;
        SIGSEGV|11)
            echo "ALERT: Process $pid crashed (SIGSEGV)" >> $ALERT_LOG
            send_alert "Process $pid crashed (SIGSEGV)"
            ;;
        SIGABRT|6)
            echo "ALERT: Process $pid aborted (SIGABRT)" >> $ALERT_LOG
            send_alert "Process $pid aborted (SIGABRT)"
            ;;
    esac
}

# 监控进程终止
monitor_process_termination() {
    while true; do
        # 检查最近终止的进程
        dmesg | grep "killed process" | tail -10 | while read line; do
            local pid=$(echo $line | grep -oP 'pid \K\d+')
            local signal=$(echo $line | grep -oP 'signal \K\d+')
            
            if [ -n "$pid" ] && [ -n "$signal" ]; then
                detect_abnormal_termination $pid $signal
            fi
        done
        
        sleep 60
    done
}

# 安全终止进程
safe_kill() {
    local pid=$1
    local signal=${2:-TERM}
    
    # 验证进程权限
    local current_user=$(whoami)
    local process_user=$(ps -p $pid -o user --no-headers)
    
    if [ "$current_user" != "root" ] && [ "$current_user" != "$process_user" ]; then
        echo "ERROR: Permission denied to kill process $pid"
        return 1
    fi
    
    # 验证进程存在
    if ! ps -p $pid > /dev/null 2>&1; then
        echo "ERROR: Process $pid not found"
        return 1
    fi
    
    # 记录审计日志
    audit_process_termination $pid $signal
    
    # 发送信号
    kill -$signal $pid
    
    if [ $? -eq 0 ]; then
        echo "Signal $signal sent to process $pid"
        return 0
    else
        echo "ERROR: Failed to send signal to process $pid"
        return 1
    fi
}

# 批量安全终止
batch_safe_kill() {
    local pattern=$1
    local signal=${2:-TERM}
    
    local pids=$(pgrep "$pattern")
    
    if [ -z "$pids" ]; then
        echo "No processes found matching: $pattern"
        return 1
    fi
    
    echo "Found processes: $pids"
    echo "Sending $signal to all matching processes..."
    
    for pid in $pids; do
        safe_kill $pid $signal
    done
}

# 发送告警
send_alert() {
    local message=$1
    
    if [ "$ENABLE_EMAIL_ALERTS" = "true" ]; then
        echo "$message" | mail -s "Process Security Alert" $ALERT_EMAIL
    fi
    
    if [ "$ENABLE_SLACK_ALERTS" = "true" ]; then
        curl -X POST -H 'Content-type: application/json' --data "{\"text\":\"$message\"}" $SLACK_WEBHOOK
    fi
}

# 主函数
main() {
    case "$1" in
        kill)
            safe_kill "$2" "$3"
            ;;
        batch)
            batch_safe_kill "$2" "$3"
            ;;
        monitor)
            monitor_process_termination
            ;;
        *)
            echo "Usage: $0 {kill|batch|monitor}"
            exit 1
            ;;
    esac
}

main "$@"