Go语言：通过进程名检查进程运行状态的实用方法

package main

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

// IsProcessRunningByName checks if a process with the given name is running using 'pgrep -x'.
// It returns true if at least one process with the exact name is found, false otherwise.
// An error is returned if the 'pgrep' command itself fails for reasons other than "process not found".
func IsProcessRunningByName(processName string) (bool, error) {
    // 使用 'pgrep -x' 进行精确匹配，如果找到进程则退出码为0，否则为1。
    // '-q' 选项可以使 pgrep 不输出 PID，只关注退出码，但此处我们不需要。
    // exec.Command("pgrep", "-x", processName)
    cmd := exec.Command("pgrep", "-x", processName) // -x for exact match

    // Run() 方法会执行命令并等待其完成。
    // 如果命令以非零状态码退出，Run() 会返回一个 *exec.ExitError。
    err := cmd.Run()

    if err != nil {
        if exitError, ok := err.(*exec.ExitError); ok {
            // pgrep 返回退出状态码1表示没有找到匹配的进程。
            // 任何其他非零状态码可能表示其他错误（例如，命令不存在，权限问题等）。
            if exitError.ExitCode() == 1 {
                return false, nil // 进程未找到
            }
            // 对于其他非零退出码，认为是命令执行失败
            return false, fmt.Errorf("pgrep 命令执行失败，退出码 %d: %w", exitError.ExitCode(), err)
        }
        // 如果不是 ExitError，则是其他执行错误（例如，命令找不到）
        return false, fmt.Errorf("无法运行 pgrep 命令: %w", err)
    }

    // 如果 Run() 返回 nil，表示 pgrep 以退出状态码0完成，即找到了匹配的进程。
    return true, nil // 进程正在运行
}

func main() {
    // 示例用法：检查常见的系统进程
    processesToFind := []string{"sshd", "nginx", "systemd", "non_existent_app"}

    for _, pName := range processesToFind {
        isRunning, err := IsProcessRunningByName(pName)
        if err != nil {
            fmt.Printf("检查进程 '%s' 时发生错误: %v\n", pName, err)
            continue
        }

        if isRunning {
            fmt.Printf("进程 '%s' 正在运行。\n", pName)
        } else {
            fmt.Printf("进程 '%s' 未运行。\n", pName)
        }
    }
}

package main

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

// IsProcessRunningByNameWindows checks if a process is running on Windows using 'tasklist'.
func IsProcessRunningByNameWindows(processName string) (bool, error) {
    // tasklist /FI "IMAGENAME eq processName.exe"
    // 注意：Windows进程名通常带有 .exe 后缀
    cmd := exec.Command("tasklist", "/FI", fmt.Sprintf("IMAGENAME eq %s.exe", processName))
    output, err := cmd.Output()

    if err != nil {
        // tasklist 在找不到进程时通常不会返回非零退出码，而是输出 "信息: 没有运行的任务符合指定的条件。"
        // 所以需要检查输出内容
        if exitError, ok := err.(*exec.ExitError); ok {
            // 如果是其他错误，例如命令找不到，则返回错误
            return false, fmt.Errorf("tasklist 命令执行失败，退出码 %d: %w", exitError.ExitCode(), err)
        }
        return false, fmt.Errorf("无法运行 tasklist 命令: %w", err)
    }

    // 检查输出中是否包含进程名，如果包含说明进程正在运行
    // tasklist 的输出可能很大，需要谨慎处理
    if strings.Contains(string(output), processName+".exe") {
        return true, nil
    }

    return false, nil
}

func main() {
    // 此处仅为示例，实际运行时请确保在Windows环境
    // isRunning, err := IsProcessRunningByNameWindows("chrome")
    // if err != nil {
    //  fmt.Println("Error:", err)
    // } else {
    //  fmt.Printf("Chrome running on Windows: %t\n", isRunning)
    // }
}

package main

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

// IsProcessRunningByNameProcfs checks if a process with the given name is running by parsing /proc.
// This function is Linux-specific.
func IsProcessRunningByNameProcfs(processName string) (bool, error) {
    // 读取 /proc 目录下的所有条目
    dirs, err := ioutil.ReadDir("/proc")
    if err != nil {
        return false, fmt.Errorf("无法读取 /proc 目录: %w", err)
    }

    for _, dir := range dirs {
        // 检查是否为数字命名的目录 (即PID目录)
        if !dir.IsDir() {
            continue
        }
        pid, err := strconv.Atoi(dir.Name())
        if err != nil {
            // 不是PID目录，跳过
            continue
        }

        // 尝试读取 /proc/<pid>/comm 文件
        commPath := fmt.Sprintf("/proc/%d/comm", pid)
        commBytes, err := ioutil.ReadFile(commPath)
        if err == nil {
            // comm 文件内容通常以换行符结尾，需要TrimSpace
            commName := strings.TrimSpace(string(commBytes))
            if commName == processName {
                return true, nil // 找到匹配的进程
            }
        } else if !os.IsNotExist(err) {
            // 如果不是文件不存在的错误，则记录警告，但继续查找
            // fmt.Printf("警告: 无法读取 %s: %v\n", commPath, err)
        }

        // 也可以选择读取 /proc/<pid>/cmdline 进行更复杂的匹配
        // cmdlinePath := fmt.Sprintf("/proc/%d/cmdline", pid)
        // cmdlineBytes, err := ioutil.ReadFile(cmdlinePath)
        // if err == nil {
        //  // cmdline 文件内容是空字符分隔的，需要替换
        //  cmdline := strings.ReplaceAll(string(cmdlineBytes), "\x00", " ")
        //  if strings.Contains(cmdline, processName) { // 或者更精确的匹配
        //      return true, nil
        //  }
        // } else if !os.IsNotExist(err) {
        //  // fmt.Printf("警告: 无法读取 %s: %v\n", cmdlinePath, err)
        // }
    }
    return false, nil // 未找到匹配的进程
}

// 注意：此处的 main 函数仅为演示，与上一个 main 函数不兼容。
// 在实际应用中，您会选择其中一种方法。
// func main() {
//  // 仅在 Linux 系统上运行此示例
//  if runtime.GOOS == "linux" {
//      processToFind := "systemd" // 尝试查找一个常见的Linux进程
//      isRunning, err := IsProcessRunningByNameProcfs(processToFind)
//      if err != nil {
//          fmt.Printf("通过 procfs 检查进程 '%s' 时发生错误: %v\n", processToFind, err)
//          return
//      }
//      if isRunning {
//          fmt.