Windows服务启动时阻止目标进程，实现进程退出后持续运行并更新DLL

作为常年折腾Windows服务和系统级操作的开发者，我来给你梳理一套既能完成更新、又能把用户影响降到最低的方案，完全贴合你的需求：

一、先解决「目标进程先于服务启动」的问题：临时拦截进程开机启动 #

既然服务启动可能滞后于explorer这类关键进程，我们得先从源头阻止它们在更新完成前启动，同时保证更新后能完全恢复正常。这里有两个靠谱的思路：

1. 临时修改启动项（用户态服务可直接实现） #

系统权限的服务可以直接修改注册表中的开机启动项，步骤如下：

• 先备份目标进程的启动配置：比如explorer的核心启动项在HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\Shell，还有用户启动文件夹、HKLM\Software\Microsoft\Windows\CurrentVersion\Run里的相关项。把这些值存到服务的专属临时存储（比如自己创建的注册表键或本地加密文件）。
• 替换启动项为一个轻量等待程序：这个小程序你自己用C++写就行，逻辑很简单——等待服务发送的信号（比如用命名事件CreateEvent），收到信号后再启动原来的目标进程。这样用户开机后，只会看到短暂的桌面加载延迟，完全不会被强制关闭进程。
• 注意：如果服务启动时发现目标进程已经在运行（比如用户手动启动了），直接跳过启动项修改，进入后续等待流程。

2. 内核级进程创建拦截（更精准，需配合驱动） #

如果你的服务可以搭配一个小型内核驱动，用PsSetCreateProcessNotifyRoutineEx注册进程创建回调。当检测到目标进程要启动时，暂时阻止它（可以返回STATUS_ACCESS_DENIED或延迟启动），直到更新完成后再解除拦截。这种方法不会修改用户的启动项，更隐蔽，但需要处理驱动签名和安装的合规问题。

二、等待目标进程自然退出，无干扰完成更新 #

当启动拦截设置好后，接下来处理已经在运行的进程：

• 枚举加载目标DLL的进程：用CreateToolhelp32Snapshot配合Module32First/Module32Next枚举系统中所有进程，检查每个进程是否加载了要更新的DLL，记录这些进程的PID。
• 安全等待进程退出：对每个目标进程，用OpenProcess(PROCESS_SYNCHRONIZE, FALSE, pid)获取仅同步权限的句柄，然后用WaitForMultipleObjects等待所有进程句柄。这里要注意：
  • 绝对不要用TerminateProcess强制关闭，完全等待用户自然关闭进程（比如用户注销、手动重启explorer）。
  • 定期检查是否有新的进程加载了旧DLL（防止拦截失效或漏网之鱼），如果有，把新进程加入等待列表。
• 执行更新：当所有目标进程都退出后，直接替换DLL文件（系统权限下可以覆盖大部分被锁定的文件，只要没有进程占用）。

三、保障服务持续运行，避免意外影响用户 #

服务的稳定性是核心，要做好这些细节：

• 异常处理与回滚：如果更新失败、服务意外停止，一定要恢复之前备份的启动项，不然用户下次开机可能无法正常启动explorer这类关键进程。可以在服务的ServiceStop回调里执行回滚逻辑。
• 定期检查机制：不要死等进程退出，设置定时器（比如每隔5分钟）重新枚举进程，避免因为句柄失效或新进程启动导致遗漏。
• 低资源占用：等待进程的逻辑要放在单独的线程里，不要阻塞服务的主循环，保证服务能响应系统的控制请求。

核心代码片段参考 #

这里给你一段C++的核心逻辑框架，实现进程枚举和等待：

#include <windows.h>
#include <tlhelp32.h>
#include <vector>
#include <string>

// 枚举加载指定DLL的进程，返回进程句柄列表
std::vector<HANDLE> GetProcessesWithTargetDLL(const std::wstring& dllName) {
    std::vector<HANDLE> processHandles;
    HANDLE processSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (processSnapshot == INVALID_HANDLE_VALUE) return processHandles;

    PROCESSENTRY32 pe32 = {sizeof(PROCESSENTRY32)};
    if (Process32First(processSnapshot, &pe32)) {
        do {
            // 仅获取同步权限，避免不必要的权限
            HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_SYNCHRONIZE, FALSE, pe32.th32ProcessID);
            if (!hProcess) continue;

            HANDLE moduleSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, pe32.th32ProcessID);
            if (moduleSnapshot == INVALID_HANDLE_VALUE) {
                CloseHandle(hProcess);
                continue;
            }

            MODULEENTRY32 me32 = {sizeof(MODULEENTRY32)};
            if (Module32First(moduleSnapshot, &me32)) {
                do {
                    if (_wcsicmp(me32.szModule, dllName.c_str()) == 0) {
                        processHandles.push_back(hProcess);
                        break;
                    }
                } while (Module32Next(moduleSnapshot, &me32));
            }
            CloseHandle(moduleSnapshot);
        } while (Process32Next(processSnapshot, &pe32));
    }
    CloseHandle(processSnapshot);
    return processHandles;
}

// 等待所有目标进程退出
void WaitForTargetProcesses(const std::vector<HANDLE>& handles) {
    if (handles.empty()) return;
    // 无限等待，直到所有进程退出
    WaitForMultipleObjects(handles.size(), handles.data(), TRUE, INFINITE);
    // 释放所有句柄
    for (HANDLE h : handles) {
        CloseHandle(h);
    }
}

内容的提问来源于stack exchange，提问作者Enosh Cohen