Golang中windows环境下c:= exec.CommandContext(ctx, ...) + c.Output()在上下文过期后进程被终止但未返回子进程终止的问题

这是一个典型的Windows进程树管理问题。在Windows上，exec.CommandContext创建的进程及其子进程构成了一个进程树，当父进程被终止时，子进程可能不会自动终止，导致Go的WaitForSingleObject无限期等待。

问题在于Windows的进程终止机制与Unix-like系统不同。在Windows上，终止父进程不会自动终止子进程，而Go的exec包在Windows上只等待直接创建的那个进程句柄。

以下是几种解决方案：

方案1：使用任务终止整个进程树（推荐）

package main

import (
	"context"
	"fmt"
	"os/exec"
	"syscall"
	"time"
)

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	// 设置进程创建标志，允许创建独立的进程树
	c := exec.CommandContext(ctx, "cmd.exe", "/c", "start", "/wait", "notepad.exe")
	c.SysProcAttr = &syscall.SysProcAttr{
		CreationFlags: syscall.CREATE_NEW_PROCESS_GROUP,
	}

	_, err := c.Output()
	fmt.Println("end", "err", err)
}

方案2：手动管理进程树终止

package main

import (
	"context"
	"fmt"
	"os/exec"
	"syscall"
	"time"
	"unsafe"
)

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	c := exec.CommandContext(ctx, "cmd.exe", "/c", "start", "/wait", "notepad.exe")
	
	// 启动进程但不等待
	c.Start()
	
	// 等待上下文超时或进程结束
	done := make(chan error, 1)
	go func() {
		done <- c.Wait()
	}()
	
	select {
	case <-ctx.Done():
		// 上下文超时，强制终止整个进程树
		terminateProcessTree(c.Process.Pid)
		<-done // 清理等待
		fmt.Println("context timeout, process tree terminated")
	case err := <-done:
		fmt.Println("process completed", "err", err)
	}
}

func terminateProcessTree(pid int) {
	// 使用taskkill终止整个进程树
	cmd := exec.Command("taskkill", "/F", "/T", "/PID", fmt.Sprintf("%d", pid))
	cmd.Run()
}

方案3：使用Job Object限制进程树（最可靠）

package main

import (
	"context"
	"fmt"
	"os/exec"
	"syscall"
	"time"
	"unsafe"
)

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	c := exec.CommandContext(ctx, "cmd.exe", "/c", "start", "/wait", "notepad.exe")
	
	// 创建Job Object来管理进程树
	jobHandle, err := createJobObject()
	if err != nil {
		fmt.Println("create job object failed:", err)
		return
	}
	defer syscall.CloseHandle(jobHandle)
	
	// 设置Job Object在父进程结束时终止所有子进程
	info := syscall.JOBOBJECT_EXTENDED_LIMIT_INFORMATION{
		BasicLimitInformation: syscall.JOBOBJECT_BASIC_LIMIT_INFORMATION{
			LimitFlags: syscall.JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE,
		},
	}
	
	_, err = syscall.SetInformationJobObject(
		jobHandle,
		syscall.JobObjectExtendedLimitInformation,
		uintptr(unsafe.Pointer(&info)),
		uint32(unsafe.Sizeof(info)),
	)
	if err != nil {
		fmt.Println("set job object info failed:", err)
		return
	}
	
	c.SysProcAttr = &syscall.SysProcAttr{
		CreationFlags: syscall.CREATE_SUSPENDED,
	}
	
	c.Start()
	
	// 将进程分配到Job Object
	err = syscall.AssignProcessToJobObject(jobHandle, syscall.Handle(c.Process.Pid))
	if err != nil {
		fmt.Println("assign process to job failed:", err)
		c.Process.Kill()
		return
	}
	
	// 恢复进程执行
	syscall.ResumeThread(syscall.Handle(c.Process.Pid))
	
	_, err = c.Output()
	fmt.Println("end", "err", err)
}

func createJobObject() (syscall.Handle, error) {
	name, err := syscall.UTF16PtrFromString("GoExecJob")
	if err != nil {
		return 0, err
	}
	
	handle, err := syscall.CreateJobObject(nil, name)
	if err != nil {
		return 0, err
	}
	
	return handle, nil
}

方案4：使用更简单的命令结构

package main

import (
	"context"
	"fmt"
	"os/exec"
	"time"
)

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()
	
	// 避免使用start /wait，直接运行程序
	c := exec.CommandContext(ctx, "notepad.exe")
	
	_, err := c.Output()
	fmt.Println("end", "err", err)
}

关键点说明：

1. Windows的进程管理与Unix-like系统不同，父进程终止不会自动终止子进程
2. start /wait创建了一个新的进程树，导致Go只等待cmd.exe而忽略了notepad.exe
3. 使用Job Object是Windows上管理进程树最可靠的方式
4. 在可能的情况下，简化命令结构可以避免这类问题

方案3（Job Object）是最彻底的解决方案，它能确保整个进程树在上下文超时或被取消时完全终止。方案1和方案2在大多数情况下也能工作，但可能在某些边缘情况下不够可靠。