Ist das Schreiben in „stdout“ in Go wirklich Thread-sicher?

Ist gleichzeitiges Schreiben auf stdout threadsicher?

Diese Frage bezieht sich auf die Thread-Sicherheit gleichzeitiger Schreibvorgänge in den Standardausgabestrom (stdout). Gehen. Betrachten Sie insbesondere den folgenden 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>

Obwohl es offensichtlich keinen Datenwettlauf gibt, gab es einige Debatten über die Thread-Sicherheit dieses Codes. Um dieses Problem zu klären, befassen wir uns mit den Mechanismen des Schreibens in stdout und untersuchen die Empfehlungen und Referenzen.

FMT-Paket und IO.Writer

Das FMT-Paket funktioniert: Akzeptieren Sie beispielsweise fmt.Fprintf ein Argument, das die io.Writer-Schnittstelle implementiert. Sie rufen intern die Write-Methode dieser Schnittstelle auf.

Betriebssystem und gleichzeitiger Zugriff auf stdout

os.Stdout ist eine Implementierung der io.Writer-Schnittstelle, an die die Ausgabe weitergeleitet wird die Standardausgabe des Systems. Wenn mehrere Goroutinen gleichzeitig in os.Stdout schreiben, wird die eigentliche Semantik dieser Operation an das zugrunde liegende Betriebssystem delegiert.

Bei POSIX-Systemen wird der Systemaufruf write(2) verwendet. POSIX gibt an, dass gleichzeitige write(2)-Aufrufe für reguläre Dateien und symbolische Links atomar sind. Diese Garantie erstreckt sich jedoch nicht auf andere Dateitypen oder auf Nicht-POSIX-Systeme.

Go-Standardbibliothek und Wrapper

Die Go-Standardbibliothek stellt Wrapper zum Schreiben bereit Dateideskriptoren und Sockets. Diese Wrapper implementieren die io.Writer-Schnittstelle und leiten im Fall von os.Stdout Vorgänge an den entsprechenden Systemaufruf um.

Die Go-Laufzeit stellt sicher, dass diese Wrapper intern für den gleichzeitigen Zugriff sicher sind. Sie leiten die Schreibvorgänge jedoch einfach an das zugrunde liegende Betriebssystem weiter, sodass die Parallelitätssemantik letztendlich vom Betriebssystem bestimmt wird.

Auswirkungen für gleichzeitige stdout-Schreibvorgänge

• Gleichzeitige Aufrufe von fmt.Fprintf, die in os.Stdout schreiben, sind für die gleichzeitige Verwendung innerhalb der Go-Laufzeit sicher.
• Die tatsächliche Reihenfolge der Ausgabe ist möglicherweise nicht deterministisch und hängt von Faktoren wie dem Betriebssystem, der Go-Laufzeit usw. ab. und Systemlast.

Empfehlungen

• Wenn die Reihenfolge der Ausgabe von gleichzeitigen Schreibvorgängen auf stdout kritisch ist, sollten Sie die Verwendung von Synchronisierungsmechanismen in Betracht ziehen, um eine bestimmte zu erzwingen Bestellung.
• Das Protokollpaket stellt ein Protokollierungsframework bereit, das threadsichere Protokollierung auf stdout (oder anderen Zielen) mit steuerbaren Zeitstempeln und Protokollheadern umfasst.

Referenzen

• POSIX write(2)-Systemaufruf: https://pubs.opengroup.org/onlinepubs/9699919799/functions/write.html
• io.Writer-Schnittstelle in Go: https://pkg.go.dev/io#Writer
• Fmt-Paket in Go: https://pkg.go.dev/fmt
• Protokollpaket in Go: https:// pkg.go.dev/log

Das obige ist der detaillierte Inhalt vonIst das Schreiben in „stdout“ in Go wirklich Thread-sicher?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!