我想按需取消正在运行的命令，为此，我正在尝试，exec.CommandContext https://golang.org/pkg/os/exec/#CommandContext，目前正在尝试这个：

https://play.golang.org/p/0JTD9HKvyad https://play.golang.org/p/0JTD9HKvyad

package main

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

func Run(quit chan struct{}) {
    ctx, cancel := context.WithCancel(context.Background())
    cmd := exec.CommandContext(ctx, "sleep", "300")
    err := cmd.Start()
    if err != nil {
        log.Fatal(err)
    }

    go func() {
        log.Println("waiting cmd to exit")
        err := cmd.Wait()
        if err != nil {
            log.Println(err)
        }
    }()

    go func() {
        select {
        case <-quit:
            log.Println("calling ctx cancel")
            cancel()
        }
    }()
}

func main() {
    ch := make(chan struct{})
    Run(ch)
    select {
    case <-time.After(3 * time.Second):
        log.Println("closing via ctx")
        ch <- struct{}{}
    }
}

我面临的问题是cancel()被调用但进程没有被杀死，我的猜测是主线程先退出并且不等待cancel()正确终止命令，主要是因为如果我使用time.Sleep(time.Second)在结束时main它退出/终止正在运行的命令。

关于我如何能有任何想法wait确保该命令在退出之前已被终止，而不是使用sleep？可以吗cancel()成功杀死命令后在通道中使用？

在尝试使用单个 goroutine 时，我尝试了以下操作：https://play.golang.org/p/r7IuEtSM-gL https://play.golang.org/p/r7IuEtSM-gL但是cmd.Wait()似乎一直在阻塞select并且无法致电cancel()

在Go中，如果结束则程序将停止main方法（在main包）已到达。 Go 语言规范中描述了此行为程序执行部分 https://golang.org/ref/spec#Program_execution（强调我自己的）：

程序执行开始于初始化main封装然后调用函数main。当该函数调用返回时，程序退出。它不会等待其他（非主）goroutines 完成。

Defects

我将考虑您的每个示例及其相关的控制流缺陷。您将在下面找到 Go Playground 的链接，但这些示例中的代码不会在限制性 Playground 沙箱中执行，因为sleep找不到可执行文件。复制并粘贴到您自己的环境中进行测试。

多个 Goroutine 示例

case <-time.After(3 * time.Second):
        log.Println("closing via ctx")
        ch <- struct{}{}

在计时器触发并且您向 goroutine 发出信号后，是时候杀死孩子并停止工作了，没有什么会导致main方法阻止并等待此完成，因此它返回。根据语言规范，程序退出。

调度程序可能会在通道传输后触发，因此之间可能存在竞争main退出并且其他 goroutine 醒来接收来自ch。然而，假设任何特定的行为交错是不安全的——而且，出于实际目的，之前不太可能发生任何有用的工作main退出。这sleep子进程将是orphaned https://en.wikipedia.org/wiki/Orphan_process;在 Unix 系统上，操作系统通常会将进程重新定位到init过程。

单个 goroutine 示例

在这里，你遇到了相反的问题：main不返回，因此子进程不会被终止。这种情况只有在子进程退出时（5分钟后）才能解决。出现这种情况是因为：

• 致电给cmd.Wait in the Run方法是一个阻塞调用（docs https://golang.org/pkg/os/exec/#Cmd.Wait). The select语句被阻塞等待cmd.Wait返回错误值，因此无法从quit渠道。

• The quit通道（声明为ch in main) is an 无缓冲通道。无缓冲通道上的发送操作将阻塞，直到接收器准备好接收数据。来自频道语言规范 https://golang.org/ref/spec#Channel_types（再次强调我自己的）：

  容量（以元素数量表示）设置通道中缓冲区的大小。如果容量为零或不存在，则通道无缓冲并且只有当发送方和接收方都准备好时，通信才能成功.

  As Run被封锁在cmd.Wait，没有准备好的接收器来接收通道上传输的值ch <- struct{}{}中的声明main方法。main阻止等待传输此数据，从而阻止进程返回。

我们可以通过小的代码调整来演示这两个问题。

cmd.Wait正在阻塞

暴露阻塞本质cmd.Wait，声明以下函数并用它代替Wait称呼。该函数是一个包装器，其行为与cmd.Wait，但是打印 STDOUT 发生的情况会产生额外的副作用。 （游乐场链接 https://play.golang.org/p/BTN9i_9oW9d):

func waitOn(cmd *exec.Cmd) error {
    fmt.Printf("Waiting on command %p\n", cmd)
    err := cmd.Wait()
    fmt.Printf("Returning from waitOn %p\n", cmd)
    return err
}

// Change the select statement call to cmd.Wait to use the wrapper
case e <- waitOn(cmd):

运行这个修改后的程序后，您将观察到输出Waiting on command <pointer>到控制台。定时器触发后，您将观察输出calling ctx cancel，但没有对应的Returning from waitOn <pointer>文本。这种情况只会在子进程返回时发生，您可以通过将睡眠持续时间减少到更小的秒数（我选择 5 秒）来快速观察到这一点。

在退出频道上发送，ch, blocks

main无法返回，因为用于传播退出请求的信号通道未缓冲并且没有相应的侦听器。通过改变线路：

    ch := make(chan struct{})

to

    ch := make(chan struct{}, 1)

通道上的发送main将继续（到通道的缓冲区）并且main将退出——与多个 goroutine 示例的行为相同。然而，这个实现仍然有问题：在实际开始停止子进程之前，不会从通道的缓冲区读取该值main返回，因此子进程仍将是孤立进程。

固定版本

我已经为您制作了一个固定版本，代码如下。还有一些风格上的改进可以将您的示例转换为更惯用的 go：

• 不需要通过通道间接发出何时停止的信号。相反，我们可以通过将上下文和取消函数的声明提升到main方法。可以在适当的时候直接取消上下文。

  我保留了单独的Run函数来演示以这种方式传递上下文，但在许多情况下，其逻辑可以嵌入到main方法，生成一个 goroutine 来执行cmd.Wait阻止呼叫。

• The select中的声明main方法是不必要的，因为它只有一个case陈述。
• sync.WaitGroup https://golang.org/pkg/sync/#WaitGroup引入是为了明确地解决以下问题main在子进程（在单独的 goroutine 中等待）被终止之前退出。等待组实现一个计数器；打电话给Wait阻塞直到所有 goroutine 完成工作并调用Done.

package main

import (
    "context"
    "log"
    "os/exec"
    "sync"
    "time"
)

func Run(ctx context.Context) {
    cmd := exec.CommandContext(ctx, "sleep", "300")
    err := cmd.Start()
    if err != nil {
        // Run could also return this error and push the program
        // termination decision to the `main` method.
        log.Fatal(err)
    }

    err = cmd.Wait()
    if err != nil {
        log.Println("waiting on cmd:", err)
    }
}

func main() {
    var wg sync.WaitGroup
    ctx, cancel := context.WithCancel(context.Background())

    // Increment the WaitGroup synchronously in the main method, to avoid
    // racing with the goroutine starting.
    wg.Add(1)
    go func() {
        Run(ctx)
        // Signal the goroutine has completed
        wg.Done()
    }()

    <-time.After(3 * time.Second)
    log.Println("closing via ctx")
    cancel()

    // Wait for the child goroutine to finish, which will only occur when
    // the child process has stopped and the call to cmd.Wait has returned.
    // This prevents main() exiting prematurely.
    wg.Wait()
}

(游乐场链接 https://play.golang.org/p/_i313PNpmKJ)