go channel 概述 - 管道

概述

unix/linux OS 的一个进程的输出可以是另一个进程的输入，这些进程使用stdin与stdout设备作为通道，在进程之间传递数据。

同样的，GO中有io.Reader与io.Writer两个接口，如果要对一个设备进行读/写，调用实现了这两个接口的方法即可。

GO对管道的支持

func t1()  {
    cmd0 := exec.Command("echo","-n","how are you")
    fmt.Println(cmd0)
}

exec.Command返回的对象的几个主要方法：

    // Stdin specifies the process's standard input.
    //
    // If Stdin is nil, the process reads from the null device (os.DevNull).
    //
    // If Stdin is an *os.File, the process's standard input is connected
    // directly to that file.
    //
    // Otherwise, during the execution of the command a separate
    // goroutine reads from Stdin and delivers that data to the command
    // over a pipe. In this case, Wait does not complete until the goroutine
    // stops copying, either because it has reached the end of Stdin
    // (EOF or a read error) or because writing to the pipe returned an error.
    Stdin io.Reader
 
    // Stdout and Stderr specify the process's standard output and error.
    //
    // If either is nil, Run connects the corresponding file descriptor
    // to the null device (os.DevNull).
    //
    // If either is an *os.File, the corresponding output from the process
    // is connected directly to that file.
    //
    // Otherwise, during the execution of the command a separate goroutine
    // reads from the process over a pipe and delivers that data to the
    // corresponding Writer. In this case, Wait does not complete until the
    // goroutine reaches EOF or encounters an error.
    //
    // If Stdout and Stderr are the same writer, and have a type that can
    // be compared with ==, at most one goroutine at a time will call Write.
    Stdout io.Writer
    Stderr io.Writer

示例

/*
参数传入的是命令组
通过buffer一次次读取返回结果，不怕返回的数据量大
如果命令是shell那样有|管道符，则使用Pip方法即可
 */
func PipCmd(cmd []string,useBufferIO... bool) string {
    useBufferedIO := false
 
    ll := len(useBufferIO)
    if ll > 0 {
        useBufferedIO = useBufferIO[0]
    }
    cmd0 := Command(cmd)
    stdout0, err := cmd0.StdoutPipe()
    if err != nil {
        fmt.Printf("Error: Couldn't obtain the stdout pipe for command : %s\n", err)
        return ""
    }
    defer stdout0.Close()
    if err := cmd0.Start(); err != nil {
        fmt.Printf("Error: The command  can not be startup: %s\n", err)
        return ""
    }
    if !useBufferedIO {
        var outputBuf0 bytes.Buffer
        for {
            tempOutput := make([]byte, 1024)
            n, err := stdout0.Read(tempOutput)
            if err != nil {
                if err == io.EOF {
                    break
                } else {
                    fmt.Printf("Error: Couldn't read data from the pipe: %s\n", err)
                    return ""
                }
            }
            if n > 0 {
                outputBuf0.Write(tempOutput[:n])
            }
        }
        //fmt.Printf("%s\n", outputBuf0.String())
        res := fmt.Sprintf("%v",outputBuf0.String())
        return res
    } else {
        outputBuf0 := bufio.NewReader(stdout0)
        var resBuffer bytes.Buffer
 
        for{
            //outputBuf0 默认带一个4K的缓冲区，第二个参数为false表示读取完所有的行
            output0, _, err := outputBuf0.ReadLine()
 
            if err != nil {
                if err == io.EOF{
                    break
                }
                fmt.Printf("Error: Couldn't read data from the pipe: %s\n", err)
                return ""
            }
            output0 = append(output0,'\n')
            resBuffer.Write(output0)
        }
        res := fmt.Sprintf("%v",resBuffer.String())
        return res
    }
}
 
func Command(cmds []string) *exec.Cmd {
    name:= cmds[0]
    cmd := &exec.Cmd{
        Path: name,
        Args: cmds,
    }
 
    if filepath.Base(name) == name {
        if lp, err := exec.LookPath(name); err != nil {
            //cmd.lookPathErr = err
            ErrorHandle(err)
        } else {
            cmd.Path = lp
        }
    }
    return cmd
}

func a11()  {
    //命令行参数不能包含空格，比如-ht 是错的，-ht是对的
    cmd := []string{"/opt/wks/go/dbm_go/src/dbm/consistency/consis_0.6.7", "-cht",  "192.168.177.67", "-cpt", "3316", "-ht","114.67.105.113,192.168.177.67", "-pt","3306,3316", "-slot",  "-json", "-db", "vodb", "-timeStart", "2020-09-11 14:09:27", "-pl", "2"}
    res := tools.PipCmd(cmd,true)
    fmt.Println(res)
}

管道的返回值

stdout0, err := cmd0.StdoutPipe()

// StdoutPipe returns a pipe that will be connected to the command's
// standard output when the command starts.
//
// Wait will close the pipe after seeing the command exit, so most callers
// need not close the pipe themselves. It is thus incorrect to call Wait
// before all reads from the pipe have completed.
// For the same reason, it is incorrect to call Run when using StdoutPipe.
// See the example for idiomatic usage.
func (c *Cmd) StdoutPipe() (io.ReadCloser, error) {
    if c.Stdout != nil {
        return nil, errors.New("exec: Stdout already set")
    }
    if c.Process != nil {
        return nil, errors.New("exec: StdoutPipe after process started")
    }
    pr, pw, err := os.Pipe()
    if err != nil {
        return nil, err
    }
    c.Stdout = pw
    c.closeAfterStart = append(c.closeAfterStart, pw)
    c.closeAfterWait = append(c.closeAfterWait, pr)
    return pr, nil
}

管道返回一个

io.ReadCloser

// ReadCloser is the interface that groups the basic Read and Close methods.
type ReadCloser interface {
    Reader
    Closer
}

不仅实现了读接口，还可以进行关闭操作

管道的内部实现

pr, pw, err := os.Pipe()

系统创建了一个管道Pipe，内部加了读锁syscall.RorkLock.RLock(),然后返回一个读文件句柄pr,和一个写文件句柄pw

// Pipe returns a connected pair of Files; reads from r return bytes written to w.
// It returns the files and an error, if any.
func Pipe() (r *File, w *File, err error) {
    var p [2]int
 
    e := syscall.Pipe2(p[0:], syscall.O_CLOEXEC)
    // pipe2 was added in 2.6.27 and our minimum requirement is 2.6.23, so it
    // might not be implemented.
    if e == syscall.ENOSYS {
        // See ../syscall/exec.go for description of lock.
        syscall.ForkLock.RLock()
        e = syscall.Pipe(p[0:])
        if e != nil {
            syscall.ForkLock.RUnlock()
            return nil, nil, NewSyscallError("pipe", e)
        }
        syscall.CloseOnExec(p[0])
        syscall.CloseOnExec(p[1])
        syscall.ForkLock.RUnlock()
    } else if e != nil {
        return nil, nil, NewSyscallError("pipe2", e)
    }
 
    return newFile(uintptr(p[0]), "|0", kindPipe), newFile(uintptr(p[1]), "|1", kindPipe), nil
}

读方法

// Reader is the interface that wraps the basic Read method.
//
// Read reads up to len(p) bytes into p. It returns the number of bytes
// read (0 <= n <= len(p)) and any error encountered. Even if Read
// returns n < len(p), it may use all of p as scratch space during the call.
// If some data is available but not len(p) bytes, Read conventionally
// returns what is available instead of waiting for more.
//
// When Read encounters an error or end-of-file condition after
// successfully reading n > 0 bytes, it returns the number of
// bytes read. It may return the (non-nil) error from the same call
// or return the error (and n == 0) from a subsequent call.
// An instance of this general case is that a Reader returning
// a non-zero number of bytes at the end of the input stream may
// return either err == EOF or err == nil. The next Read should
// return 0, EOF.
//
// Callers should always process the n > 0 bytes returned before
// considering the error err. Doing so correctly handles I/O errors
// that happen after reading some bytes and also both of the
// allowed EOF behaviors.
//
// Implementations of Read are discouraged from returning a
// zero byte count with a nil error, except when len(p) == 0.
// Callers should treat a return of 0 and nil as indicating that
// nothing happened; in particular it does not indicate EOF.
//
// Implementations must not retain p.
type Reader interface {
    Read(p []byte) (n int, err error)
}

实现读接口的对象，有一个Read方法，可以将字节读到字节数组中； 与stdin设备对应，从该设备读取字节到内存。

exec.Cmd这是一个外部命令，它可以是一个静止的命令，或者一个正在运行的命令；提供启动／停止／管道／输入输入定向支持；其中管道返回一个读文件句柄和一个写文件句柄

exec.Cmd输入输出重定向

func runCmdWithPipe() {
    fmt.Println("Run command `ps -ef | grep apipe`: ")
    cmd1 := exec.Command("ps", "-ef")
    cmd2 := exec.Command("grep", "apipe")
    var outputBuf1 bytes.Buffer
    cmd1.Stdout = &outputBuf1
    if err := cmd1.Start(); err != nil {
        fmt.Printf("Error: The first command can not be startup %s\n", err)
        return
    }
    if err := cmd1.Wait(); err != nil {
        fmt.Printf("Error: Couldn't wait for the first command: %s\n", err)
        return
    }
    cmd2.Stdin = &outputBuf1
    var outputBuf2 bytes.Buffer
    cmd2.Stdout = &outputBuf2
    if err := cmd2.Start(); err != nil {
        fmt.Printf("Error: The second command can not be startup: %s\n", err)
        return
    }
    if err := cmd2.Wait(); err != nil {
        fmt.Printf("Error: Couldn't wait for the second command: %s\n", err)
        return
    }
    fmt.Printf("%s\n", outputBuf2.Bytes())
}