在Go语言中通过进程名称检查进程是否运行

package main

import (
    "fmt"
    "os/exec"
    "strings"
)

// IsProcessRunningByName 使用pgrep检查进程是否运行
// processName: 要检查的进程名称
// exactMatch: 是否要求精确匹配进程名称（-x选项）
// fullCmdline: 是否匹配完整命令行（-f选项）
func IsProcessRunningByName(processName string, exactMatch, fullCmdline bool) (bool, error) {
    args := []string{}
    if exactMatch {
        args = append(args, "-x") // 精确匹配进程名称
    }
    if fullCmdline {
        args = append(args, "-f") // 匹配完整命令行
    }
    args = append(args, processName)

    cmd := exec.Command("pgrep", args...)
    output, err := cmd.Output()

    if err != nil {
        // pgrep在没有找到匹配项时会返回非零退出状态，这会被Go的exec包视为错误。
        // 我们需要检查错误类型，以区分“未找到”和“真正的执行错误”。
        if exitError, ok := err.(*exec.ExitError); ok {
            // 如果退出码是1（pgrep未找到匹配项的常见退出码），则认为进程未运行
            if exitError.ExitCode() == 1 {
                return false, nil
            }
            // 其他非零退出码表示pgrep执行时发生了问题
            return false, fmt.Errorf("pgrep command failed with exit code %d: %w", exitError.ExitCode(), err)
        }
        // 其他类型的错误（例如命令不存在）
        return false, fmt.Errorf("failed to execute pgrep command: %w", err)
    }

    // 如果pgrep成功执行并返回了输出，说明找到了匹配的进程
    pids := strings.TrimSpace(string(output))
    return len(pids) > 0, nil
}

func main() {
    // 示例：检查 "sshd" 进程是否运行
    isRunning, err := IsProcessRunningByName("sshd", true, false)
    if err != nil {
        fmt.Printf("检查 sshd 进程时发生错误: %v\n", err)
    } else {
        fmt.Printf("sshd 进程是否正在运行 (精确匹配): %t\n", isRunning)
    }

    // 示例：检查 "go" 相关的进程（可能匹配 "go run", "go build" 等）
    isRunningGo, err := IsProcessRunningByName("go", false, true)
    if err != nil {
        fmt.Printf("检查 go 进程时发生错误: %v\n", err)
    } else {
        fmt.Printf("是否存在包含 'go' 的进程 (匹配命令行): %t\n", isRunningGo)
    }

    // 示例：检查一个不存在的进程
    isRunningNonExistent, err := IsProcessRunningByName("nonexistent_process_123", true, false)
    if err != nil {
        fmt.Printf("检查 nonexistent_process_123 进程时发生错误: %v\n", err)
    } else {
        fmt.Printf("nonexistent_process_123 进程是否正在运行: %t\n", isRunningNonExistent)
    }
}

package main

import (
    "fmt"
    "io/ioutil"
    "os"
    "path/filepath"
    "strconv"
    "strings"
)

// IsProcessRunningByProcfsName 通过读取procfs检查进程是否运行（仅限Linux）
func IsProcessRunningByProcfsName(processName string) (bool, error) {
    // 遍历 /proc 目录
    entries, err := ioutil.ReadDir("/proc")
    if err != nil {
        return false, fmt.Errorf("无法读取 /proc 目录: %w", err)
    }

    for _, entry := range entries {
        // 检查是否是数字目录（PID）
        if !entry.IsDir() {
            continue
        }
        pidStr := entry.Name()
        if _, err := strconv.Atoi(pidStr); err != nil {
            continue // 不是数字，跳过
        }

        // 构建 comm 文件的路径
        commPath := filepath.Join("/proc", pidStr, "comm")
        content, err := ioutil.ReadFile(commPath)
        if err != nil {
            // 进程可能已经退出，或者没有读取权限，忽略
            if os.IsNotExist(err) || os.IsPermission(err) {
                continue
            }
            return false, fmt.Errorf("读取 %s 文件失败: %w", commPath, err)
        }

        // comm 文件内容末尾通常有换行符，需要去除
        actualProcessName := strings.TrimSpace(string(content))

        if actualProcessName == processName {
            return true, nil // 找到匹配的进程
        }

        // 也可以考虑读取 cmdline 文件进行更灵活的匹配
        // cmdlinePath := filepath.Join("/proc", pidStr, "cmdline")
        // cmdlineContent, err := ioutil.ReadFile(cmdlinePath)
        // if err == nil {
        //     fullCmd := strings.ReplaceAll(string(cmdlineContent), "\x00", " ") // null字节分隔
        //     if strings.Contains(fullCmd, processName) {
        //         return true, nil
        //     }
        // }
    }

    return false, nil // 未找到匹配的进程
}

func main() {
    // 仅在Linux系统上运行此部分
    if runtime.GOOS == "linux" {
        isRunning, err := IsProcessRunningByProcfsName("systemd")
        if err != nil {
            fmt.Printf("通过 procfs 检查 systemd 进程时发生错误: %v\n", err)
        } else {
            fmt.Printf("systemd 进程是否正在运行 (通过 procfs): %t\n", isRunning)
        }

        isRunningCron, err := IsProcessRunningByProcfsName("cron")
        if err != nil {
            fmt.Printf("通过 procfs 检查 cron 进程时发生错误: %v\n", err)
        } else {
            fmt.Printf("cron 进程是否正在运行 (通过 procfs): %t\n", isRunningCron)
        }

        isRunningNonExistent, err := IsProcessRunningByProcfsName("nonexistent_proc_via_procfs")
        if err != nil {
            fmt.Printf("通过 procfs 检查 nonexistent_proc_via_procfs 进程时发生错误: %v\n", err)
        } else {
            fmt.Printf("nonexistent_proc_via_procfs 进程是否正在运行 (通过 procfs): %t\n", isRunningNonExistent)
        }
    } else {
        fmt.Println("此 procfs 方法仅适用于 Linux 系统。")
    }
}