如何在多个不同的控制台中制作 goroutines output？

Question

I am practicing using goroutines and found that if both goroutines are printing at the same time, it becomes difficult to read.

func main() {
    s1 := rand.NewSource(time.Now().UnixNano())
    r1 := rand.New(s1)
    wg := &sync.WaitGroup{}
    t1 := func(wg *sync.WaitGroup) {
        for i := 0; i < 100; i++ {
            time.Sleep(time.Microsecond * time.Duration(r1.Intn(100)))
            fmt.Println("T1 : ", i)
        }
        wg.Done()
    }
    t2 := func(wg *sync.WaitGroup) {
        for i := 0; i < 100; i++ {
            time.Sleep(time.Microsecond * time.Duration(r1.Intn(100)))
            fmt.Println("T2 : ", i)
        }
        wg.Done()
    }
    wg.Add(2)
    go t1(wg)
    go t2(wg)
    wg.Wait()
}

Output:

T1 :  0
T2 :  0
T2 :  1
T1 :  1
T1 :  2
T2 :  2
T1 :  3
T2 :  3
T1 :  4
T2 :  4
T1 :  5
T2 :  5
T1 :  6
T2 :  6
T2 :  7
T1 :  7
T2 :  8
T1 :  8
T1 :  9
T2 :  9
T2 :  10
T1 :  10
......

Is there any way to open multiple consoles and let two goroutines output in different consoles?

Answer 1

1. You may use a simple TCP terminal server - first run this TCP terminal server and you don't need to close it as long as you need ( or just use Netcat Command : nc -l 8080 then goto #2 and write to this TCP connection eg "127.0.0.1:8080"):

package main

import (
    "io"
    "log"
    "net"
    "os"
)

func main() {
    ln, err := net.Listen("tcp", "127.0.0.1:8080")
    if err != nil {
        log.Fatal(err)
    }
    for {
        w1, err := ln.Accept()
        if err != nil {
            log.Fatal(err)
        }
        io.Copy(os.Stdout, w1)
        w1.Close()
    }
}

2. Then add this to your code:

    w1, err := net.Dial("tcp", "127.0.0.1:8080")
    if err != nil {
        log.Fatal(err)
    }
    defer w1.Close()

3. Then use w1 as your another io.Writer in your code eg fmt.Fprintln(w1, "T1: ", i) , an example:

package main

import (
    "fmt"
    "log"
    "math/rand"
    "net"
    "sync"
    "time"
)

func main() {
    w1, err := net.Dial("tcp", "127.0.0.1:8080")
    if err != nil {
        log.Fatal(err)
    }
    defer w1.Close()

    // your code:
    s1 := rand.NewSource(time.Now().UnixNano())
    r1 := rand.New(s1)
    wg := &sync.WaitGroup{}
    t1 := func(wg *sync.WaitGroup) {
        for i := 0; i < 100; i++ {
            time.Sleep(time.Microsecond * time.Duration(r1.Intn(100)))
            fmt.Fprintln(w1, "T1 : ", i)
        }
        wg.Done()
    }
    t2 := func(wg *sync.WaitGroup) {
        for i := 0; i < 100; i++ {
            time.Sleep(time.Microsecond * time.Duration(r1.Intn(100)))
            fmt.Println("T2 : ", i)
        }
        wg.Done()
    }
    wg.Add(2)
    go t1(wg)
    go t2(wg)
    wg.Wait()
}

Answer 2

fmt.Print*(...) functions are wrappers for fmt.Fprint*(os.Stdout, ...) . If you want to make two goroutines write to distinct writers, one first step in your code is to provide the writer they should use:

    t1 := func(wg *sync.WaitGroup, out io.Writer) {
        for i := 0; i < 100; i++ {
            time.Sleep(time.Microsecond * time.Duration(r1.Intn(100)))
            fmt.Fprintln(out, "T1 : ", i)
        }
        wg.Done()
    }

    ...

    // for starters : keep using the same os.Stdout writer
    go t1(wg, os.Stdout)

Instead of a raw io.Writer , you may want to pass something to which you can log; the standard library has the log.Logger struct:

    t1 := func(wg *sync.WaitGroup, l *log.Logger) {
        for i := 0; i < 100; i++ {
            time.Sleep(time.Microsecond * time.Duration(r1.Intn(100)))
            l.Println(i)
        }
        wg.Done()
    }

    ...

    // all logging libraries will allow you to specify some option which you can tune :
    l1 := log.New(os.Stdout, "T1 : ", log.Ltime) // will prefix all messages with "[time] T1 : "
    go t1(wg, l1)

    // this allows you to write :
    l2 := log.New(os.Stdout, "T2 : ", log.Ltime) // will prefix all messages with "[time] T2 : "
    go t2(wg, l2)

You may look into golang logging libraries for more features -- don't spend too much time on choosing a logging framework for a quick throwaway project, though.

---

Now that you have an explicit way to pass two distinct writers (or loggers) to your goroutines, choose whatever suits your need to write to:

• have goroutine 1 log to Stdout and goroutine 2 log to Stderr
• log to file1 and file2 -- just run tail -f file2 in some separate terminal to get a "live view" of the output
• io.Discard is a golang built-in equivalent of /dev/null
• log to a named pipe, a unix socket, a tcp connection...