在 Go 中正确地通过 stdin 向命令传递数据并从 stdout 接收数据

本文旨在解决在 Go 语言中使用 os/exec 包执行外部命令时，如何正确地通过标准输入 (stdin) 向命令传递数据，并从标准输出 (stdout) 接收数据的常见问题。通过分析常见的陷阱和提供可行的解决方案，本文将帮助开发者避免死锁和数据丢失，确保外部命令的顺利执行和数据的完整传输。

在使用 Go 语言的 os/exec 包执行外部命令时，通过标准输入 (stdin) 向命令传递数据，并从标准输出 (stdout) 接收数据，看似简单，实则容易遇到一些陷阱。最常见的问题是程序hang住，导致数据无法正常传递和接收。这通常是由于未正确处理 goroutine 的同步和管道的关闭导致的。

问题分析

问题的根源在于 cmd.Wait() 的行为。cmd.Wait() 会等待命令执行完毕，并且会关闭与子进程之间的所有管道，包括 stdin 和 stdout。如果写入 stdin 的 goroutine 或者读取 stdout 的 goroutine 还在运行，并且依赖于这些管道，那么就会发生死锁。

解决方案

解决这个问题的关键在于确保在 cmd.Wait() 之前，所有与子进程的通信都已经完成，并且管道都已经关闭。这可以通过以下几种方式实现：

1. 使用 sync.WaitGroup 进行同步

   sync.WaitGroup 可以用来等待一组 goroutine 执行完毕。我们可以创建一个 sync.WaitGroup，并增加计数器，然后为写入 stdin 和读取 stdout 的 goroutine 各启动一个 goroutine，并在每个 goroutine 完成后调用 wg.Done()。最后，在 cmd.Wait() 之前调用 wg.Wait()，等待所有 goroutine 执行完毕。

   以下是一个使用 sync.WaitGroup 的示例：

   

   Natural Language Playlist

   探索语言和音乐之间丰富而复杂的关系，并使用 Transformer 语言模型构建播放列表。

   67

   查看详情

   package main
   
   import (
       "bytes"
       "io"
       "log"
       "os"
       "os/exec"
       "sync"
   )
   
   func main() {
       runCatFromStdinWorks(populateStdin("aaa\n"))
       runCatFromStdinWorks(populateStdin("bbb\n"))
   }
   
   func populateStdin(str string) func(io.WriteCloser) {
       return func(stdin io.WriteCloser) {
           defer stdin.Close()
           io.Copy(stdin, bytes.NewBufferString(str))
       }
   }
   
   func runCatFromStdinWorks(populate_stdin_func func(io.WriteCloser)) {
       cmd := exec.Command("cat")
       stdin, err := cmd.StdinPipe()
       if err != nil {
           log.Panic(err)
       }
       stdout, err := cmd.StdoutPipe()
       if err != nil {
           log.Panic(err)
       }
       err = cmd.Start()
       if err != nil {
           log.Panic(err)
       }
       var wg sync.WaitGroup
       wg.Add(2)
       go func() {
           defer wg.Done()
           populate_stdin_func(stdin)
       }()
       go func() {
           defer wg.Done()
           io.Copy(os.Stdout, stdout)
       }()
       wg.Wait()
       err = cmd.Wait()
       if err != nil {
           log.Panic(err)
       }
   }

   登录后复制

   在这个例子中，我们创建了一个 sync.WaitGroup，并增加了计数器为 2。然后，我们启动了两个 goroutine，一个用于写入 stdin，另一个用于读取 stdout。每个 goroutine 在完成时调用 wg.Done()。最后，我们在 cmd.Wait() 之前调用 wg.Wait()，等待所有 goroutine 执行完毕。

2. 使用 channel 进行同步

   可以使用 channel 来通知主 goroutine，stdin 写入和 stdout 读取已经完成。

   package main
   
   import (
       "bytes"
       "fmt"
       "io"
       "log"
       "os/exec"
   )
   
   func main() {
       runCatFromStdin(populateStdin("hello\n"))
   }
   
   func populateStdin(str string) func(io.WriteCloser) {
       return func(stdin io.WriteCloser) {
           defer stdin.Close()
           io.Copy(stdin, bytes.NewBufferString(str))
       }
   }
   
   func runCatFromStdin(populate_stdin_func func(io.WriteCloser)) {
       cmd := exec.Command("cat")
       stdin, err := cmd.StdinPipe()
       if err != nil {
           log.Panic(err)
       }
       stdout, err := cmd.StdoutPipe()
       if err != nil {
           log.Panic(err)
       }
       err = cmd.Start()
       if err != nil {
           log.Panic(err)
       }
   
       stdinDone := make(chan bool)
       stdoutDone := make(chan bool)
   
       go func() {
           defer close(stdinDone)
           populate_stdin_func(stdin)
       }()
   
       go func() {
           defer close(stdoutDone)
           _, err := io.Copy(stdout, stdout)
           if err != nil {
               log.Println("Error reading stdout:", err)
           }
       }()
   
       <-stdinDone
       <-stdoutDone
   
       err = cmd.Wait()
       if err != nil {
           log.Panic(err)
       }
       fmt.Println("Command executed successfully.")
   }

   登录后复制

   在这个例子中，stdinDone 和 stdoutDone channel 分别用于通知主 goroutine stdin 写入和 stdout 读取已经完成。

注意事项

• 及时关闭 stdin： 在写入 stdin 的 goroutine 中，务必在完成写入后关闭 stdin。这可以通过在 populateStdin 函数中使用 defer stdin.Close() 来实现。如果不关闭 stdin，子进程可能会一直等待输入，导致程序hang住。
• 处理 stdout 的读取： 确保从 stdout 中读取所有数据。即使你不需要使用这些数据，也应该将其读取完毕，否则子进程可能会阻塞，导致程序hang住。
• 错误处理： 在所有步骤中都要进行错误处理，包括创建管道、启动命令、写入 stdin、读取 stdout 和等待命令完成。这可以帮助你诊断问题并避免程序崩溃。

总结

通过正确地处理 goroutine 的同步和管道的关闭，可以避免在使用 os/exec 包执行外部命令时遇到的死锁问题。sync.WaitGroup 和 channel 都是有效的同步机制，可以确保在 cmd.Wait() 之前，所有与子进程的通信都已经完成。同时，要注意及时关闭 stdin，处理 stdout 的读取，并进行错误处理，以确保程序的稳定性和可靠性。

以上就是在 Go 中正确地通过 stdin 向命令传递数据并从 stdout 接收数据的详细内容，更多请关注php中文网其它相关文章！