Windows平台Rust单实例应用如何编程强制杀死无响应进程

我开发了一款仅允许单实例运行的Windows Rust应用，采用文件锁机制确保同一时间仅一个进程运行。偶尔应用会出现无响应情况，此时用户再次启动应用无法杀死该无响应进程；但进程正常运行时，新实例可成功终止旧进程。请问是否存在强制杀死无响应进程的方法？

当前实现代码 #

lazy_static! {
    static ref LOCK_PATH: PathBuf = env::temp_dir().join("tl-lock");
    static ref EXE_NAME: String = {
        let exe_path = env::current_exe().unwrap();
        exe_path
            .file_name()
            .expect("Cannot get EXE name")
            .to_str()
            .expect("Invalid EXE name")
            .to_string()
    };
}

/// Terminate all processes that have the same name
/// This prevents people from having multiple copies open
fn kill_dangling_processes() {
    let exe_name = &*EXE_NAME;
    let sys = System::new_all();
    for (_, process) in sys.processes() {
        if process.name() == exe_name {
            process.kill();
        }
    }
}

/// This function is ran on start
pub fn lock() {
    if LOCK_PATH.exists() {
        kill_dangling_processes();
        return;
    }
    fs::write(LOCK_PATH.clone(), "locked").unwrap();
}

目前仅能通过右键点击任务栏强制杀死该无响应进程。

解决方案 #

问题根源 #

当前代码使用的process.kill()本质是向进程发送普通终止信号，但无响应进程可能已经无法处理这类信号，导致终止失败。Windows系统提供了更底层的强制终止API——TerminateProcess，它可以直接终止进程，无需进程响应。

实现步骤 #

1. 引入Win32 API依赖

在Cargo.toml中添加windows crate以调用Win32系统API：

[dependencies]
windows = { version = "0.52", features = ["Win32_System_Threading", "Win32_Foundation"] }
sysinfo = "0.29"
lazy_static = "1.4"

2. 实现强制终止进程的函数

使用TerminateProcess API直接终止目标进程：

use windows::Win32::System::Threading::{OpenProcess, TerminateProcess, PROCESS_TERMINATE};
use windows::Win32::Foundation::{HANDLE};

/// 强制终止指定PID的进程
fn force_terminate_process(pid: u32) -> bool {
    unsafe {
        // 打开进程，获取终止权限
        let process_handle = OpenProcess(PROCESS_TERMINATE, false, pid);
        if process_handle.is_invalid() {
            return false;
        }

        // 强制终止进程，退出码设为1
        let result = TerminateProcess(process_handle, 1);
        
        // 关闭进程句柄
        let _ = process_handle.close();
        
        result.as_bool()
    }
}

3. 改进文件锁机制，精准定位目标进程

原锁文件仅标记"locked"，无法精准对应持有锁的进程。改为写入当前进程ID（PID），这样新实例可以直接定位到旧进程：

/// 应用启动时执行的锁逻辑
pub fn lock() {
    let current_pid = std::process::id();
    let lock_path = &*LOCK_PATH;

    if lock_path.exists() {
        match fs::read_to_string(lock_path) {
            Ok(pid_str) => {
                if let Ok(target_pid) = pid_str.parse::<u32>() {
                    let sys = System::new_all();
                    if let Some(process) = sys.process(target_pid) {
                        // 先尝试正常终止
                        if !process.kill() {
                            // 正常终止失败，强制杀死
                            let _ = force_terminate_process(target_pid);
                        }
                    } else {
                        // 进程已不存在，删除无效锁文件
                        let _ = fs::remove_file(lock_path);
                    }
                } else {
                    // 锁文件内容无效，删除后重新创建
                    let _ = fs::remove_file(lock_path);
                    let _ = fs::write(lock_path, current_pid.to_string());
                }
            }
            Err(_) => {
                // 读取锁文件失败，退化为杀死所有同名进程
                kill_dangling_processes();
            }
        }
        return;
    }

    // 创建新锁文件并写入当前PID
    fs::write(lock_path, current_pid.to_string()).unwrap();
}

4. 可选：判断进程是否无响应（进阶）

如果需要先判断进程是否无响应再决定是否强制终止，可以使用IsHungAppWindow API（需配合窗口查找逻辑）：

use windows::Win32::UI::WindowsAndMessaging::{IsHungAppWindow, FindWindowA};
use std::ffi::CString;

/// 判断指定窗口标题的进程是否无响应
fn is_process_unresponsive(window_title: &str) -> bool {
    unsafe {
        let title_cstr = CString::new(window_title).unwrap();
        let hwnd = FindWindowA(std::ptr::null(), title_cstr.as_ptr());
        if hwnd.is_null() {
            false
        } else {
            IsHungAppWindow(hwnd).as_bool()
        }
    }
}

你可以结合进程的窗口标题或类名，先检查进程是否无响应，再执行强制终止逻辑。

关键说明 #

• TerminateProcess是Windows系统最强制的进程终止方式，会直接终止进程，不会等待进程清理资源，因此仅在正常终止失败时使用。
• 记录PID的锁机制可以避免误杀同名进程，提升精准度。
• 确保在应用退出时删除锁文件（如在Drop实现或退出钩子中），避免遗留无效锁。

内容的提问来源于stack exchange，提问作者Ben Faerber