Is Writing to `stdout` in Go Truly Thread-Safe?

Is Concurrent Write on stdout Threadsafe?

This question pertains to the thread safety of concurrent writes to the standard output (stdout) stream in Go. Specifically, consider the following code:

<code class="go">package main

import (
    "fmt"
    "os"
    "strings"
)

func main() {
    x := strings.Repeat(" ", 1024)
    go func() {
        for {
            fmt.Fprintf(os.Stdout, x+"aa\n")
        }
    }()

    go func() {
        for {
            fmt.Fprintf(os.Stdout, x+"bb\n")
        }
    }()

    go func() {
        for {
            fmt.Fprintf(os.Stdout, x+"cc\n")
        }
    }()

    go func() {
        for {
            fmt.Fprintf(os.Stdout, x+"dd\n")
        }
    }()

    <-make(chan bool)
}</code>

Despite the lack of any apparent data race, there has been some debate regarding the thread safety of this code. To clarify this issue, let's delve into the mechanics of writing to stdout and examine the recommendations and references.

FMT Package and IO.Writer

The fmt package functions, such as fmt.Fprintf, accept an argument implementing the io.Writer interface. They internally call the Write method of this interface.

OS and Concurrent Access to stdout

os.Stdout is an implementation of the io.Writer interface that directs output to the system's standard output. When multiple goroutines concurrently write to os.Stdout, the actual semantics of this operation are delegated to the underlying operating system.

In the case of POSIX systems, the write(2) system call is used. POSIX specifies that concurrent write(2) calls are atomic for regular files and symbolic links. However, this guarantee does not extend to other file types or to non-POSIX systems.

Go Standard Library and Wrappers

The Go standard library provides wrappers for writing to file descriptors and sockets. These wrappers implement the io.Writer interface and, in the case of os.Stdout, redirect operations to the relevant system call.

The Go runtime ensures that these wrappers are internally safe for concurrent access. However, they simply relay the writes to the underlying operating system, so the concurrency semantics are ultimately determined by the OS.

Implications for Concurrent stdout Writes

• Concurrent calls to fmt.Fprintf writing to os.Stdout are safe for concurrent use within the Go runtime.
• The actual order of the output may be non-deterministic and depend on factors such as the OS, Go runtime, and system load.

Recommendations

• If the order of output from concurrent writes to stdout is critical, consider using synchronization mechanisms to enforce a specific ordering.
• The log package provides a logging framework that includes thread-safe logging to stdout (or other destinations) with controllable timestamps and log headers.

References

• POSIX write(2) system call: https://pubs.opengroup.org/onlinepubs/9699919799/functions/write.html
• io.Writer interface in Go: https://pkg.go.dev/io#Writer
• Fmt package in Go: https://pkg.go.dev/fmt
• Log package in Go: https://pkg.go.dev/log

The above is the detailed content of Is Writing to `stdout` in Go Truly Thread-Safe?. For more information, please follow other related articles on the PHP Chinese website!