sync.waitgroup koordiniert die Goroutine -Fertigstellung durch Blockieren, bis alle Goroutinen mit Add, Fertig und Warten abgeschlossen sind. 2. Sync.Mutex und sync.rwmutex schützen gemeinsam genutzte Daten mit exklusiven oder gemeinsam genutzten Sperren, wobei RWMutex h?ufige Lesevorg?nge optimiert; A. context.context erm?glicht die Ausbreitung von Stornierungen und Frist über Goroutinen, withcancel, with timeout oder Withdeadline und immer anrufen, um Lecks zu verhindern. 4. Sync.once stellt sicher, dass eine Funktion genau einmal ausgeführt wird, ideal für die Initialisierung des globalen Zustands wie Datenbankverbindungen. 5. 6. Das Atomic-Paket bietet lockfreie Vorg?nge für Primitive wie Z?hler, die Funktionen wie AddInt64 und LoadInt64 verwenden, die nur für einfache Vorg?nge geeignet sind. 7. Mit Standard ausw?hlen erm?glicht nicht blockierende Kanalvorg?nge, w?hrend Sie mit der Zeit ausw?hlen. Zusammen erm?glichen diese Primitiven robuste, effiziente gleichzeitige GO -Programme, die über grundlegende Goroutinen und Kan?le hinausgehen.

Wenn Sie an go -Anweisungen und der grundlegenden Kanalnutzung vorbeigezogen sind, enthüllt Go's Concallelrency Toolkit tiefere, leistungsst?rkere Primitive. Diese Tools helfen Ihnen beim Schreiben eines sichereren und effizienteren gleichzeitigeren Code - insbesondere in komplexen Systemen, in denen Koordination, Stornierung und gemeinsame staatliche Angelegenheit. Lassen Sie uns die wichtigsten Parallelit?tsprimitiven jenseits der Grundlagen untersuchen.

1. sync.WaitGroup - Koordination von Goroutine -Abschluss

W?hrend go eine Goroutine startet, k?nnen Sie mit sync.WaitGroup auf eine Sammlung von Goroutinen warten - ohne Kan?le.

Wann Sie es verwenden : Sie haben eine bekannte Anzahl von Goroutinen, die Arbeit erledigen, und Sie m?chten, dass die Haupt- (oder übergeordnete) Goroutine bis zum Ende blockiert.

 var wg sync.waitgroup

für i: = 0; i <5; ich {
    wg.add (1)
    Go func (id int) {
        aufschieben wg.done ()
        fmt.printf ("Worker %d Done \ n", id)
    }(ich)
}

wg.wait () // Bl?cke, bis alle Done () aufgerufen werden

Schlüsselpunkte :

• Rufen Sie immer Add(n) bevor Sie Goroutinen starten.
• Rufen Sie Done() über defer an, um sicherzustellen, dass es auch dann ausgeführt wird, wenn die Goroutine in Panik ger?t.
• Nicht sicher, eine WaitGroup ohne ordnungsgem??e Synchronisation wiederzuverwenden.

2. sync.Mutex und sync.RWMutex - Schutz der gemeinsamen Daten schützen

Kan?le eignen sich hervorragend für die Eigentümerübertragung, aber manchmal müssen Sie gemeinsam gemeinsame Daten lesen oder schreiben.

 var (
    mu sync.mutex
    Data = make (map [string] int)
)

Func Update (Schlüsselstring, Val int) {
    mu.lock ()
    aufschieben mu.unlock ()
    Daten [Schlüssel] = val
}

Func get (Schlüsselstring) int {
    mu.lock ()
    aufschieben mu.unlock ()
    Daten zurückgeben [Schlüssel]
}

Besser mit RWMutex , wenn die Lesevorg?nge h?ufig sind und selten schreibt:

 mu.rlock ()
Defer mu.runlock () aufschieben
Daten zurückgeben [Schlüssel]

• RLock() erlaubt mehreren Lesern.
• Lock() ist für exklusive (Schreib-) Zugriff.

Tipp : Vermeiden Sie es, Schl?sser w?hrend der E/A- oder langen Operationen zu halten - zuerst Daten.

3. context.Context - Stornierungs- und Fristverbreitung

Der context ist die Standardmethode zur Signalisierung von Stornieren über Goroutinen hinweg, insbesondere in HTTP-Servern, RPCs oder langlebigen Aufgaben.

 CTX, Cancel: = context.withTimeout (context.background (), 2*time.second)
Aufhebung stornieren ()

go func () {
    time.sleep (3 * time.second)
    w?hlen {
    Fall <-ctx.done ():
        fmt.println ("storniert:", ctx.err ())
    }
} ())

Gemeinsame Muster :

• Verwenden Sie context.WithCancel , WithTimeout oder WithDeadline .
• Pass ctx als erstes Argument für Funktionen.
• überprüfen Sie ctx.Done() in Schleifen oder vor teuren Vorg?ngen.
• Rufen Sie immer cancel() , um Lecks zu vermeiden.

Warum es wichtig ist : Es erm?glicht saubere, hierarchische Herunterfahren über Deep Call -Stapel.

4. sync.Once - Sicherstellung einer einzelnen Initialisierung

Nützlich für die faule Initialisierung des globalen Zustands - EG, Konfiguration, Datenbankverbindungen.

 var einmal synchronisieren
var db *sql.db

func getdb () *sql.db {
    einst.do (func () {
        db, _ = sql.open ("sqlite", "app.db")
    })
    Return DB
}

• Do(f) f genau einmal, auch unter starker Parallelit?t.
• Wenn mehrere Goroutines es nennen, wird nur einer f ausgeführt. Andere blockieren und warten.

HINWEIS : Wenn f Panik in Panik berücksichtigt wird, ist es Once ausgeführt - also kein Wiederholung.

5. sync.Pool - Reduzierung des GC -Drucks mit der Wiederverwendung von Objekten

sync.Pool richtungssübergreifend tempor?re Objekte zur Reduzierung der Allokation und der GC-Last-ideal für Hochleistungscode.

 var bufferpool = sync.pool {
    Neu: func () Schnittstelle {} {
        Neue zurückgeben (Bytes.Buffer)
    },
}

Func -Prozess (Daten [] byte) {
    buf: = bufferpool.get (). (*bytes.buffer)
    buf.reset ()
    buf.write (Daten)
    // ... BUF verwenden
    Bufferpool.put (BUF) // zurück zum Pool zurückkehren
}

Wichtig :

• Es werden keine Garantieobjekte wiederverwendet.
• Verlassen Sie sich nicht auf Pool , um Korrektheit - nur Leistung.
• Vermeiden Sie es, gro?e oder unbegrenzte Gegenst?nde in Pools zu legen.

Am besten für : Puffer, JSON -Encoder, h?ufig zugewiesene Strukturen.

6. atomic -Paket-lockfreie Vorg?nge bei Primitiven

Für einfache Operationen (z. B. Z?hler) vermeidet sync/atomic Mutex -Overhead.

 var counter int64

go func () {
    atomic.addint64 (& counter, 1)
} ())

// sicher lesen
Wert: = atomic.loadint64 (& counter)

Verfügbare Typen : int32 , int64 , uint32 , uint64 , uintptr , unsafe.Pointer .

Anwendungsf?lle :

• Performance -Z?hler.
• Flaggen (z. B. atomic.Bool über int32 ).
• Referenzz?hlung.

Achtung : Nur für einfache Operationen. Komplexe Logik ben?tigt noch Mutexes oder Kan?le.

7. select mit default und time.After .

über den einfachen Empfang hinaus kann select nicht blockierende oder zeitübergreifende Arbeiten erledigen.

Nicht blockierender Empfang :

 w?hlen {
Fall MSG: = <-ch:
    fmt.println ("empfangen:", msg)
Standard:
    fmt.println ("Keine Nachricht verfügbar")
}

Mit Auszeit :

 w?hlen {
Fall MSG: = <-ch:
    fmt.println ("Got:", msg)
Fall <-Time.After (100 * Zeit.Millisekunde):
    fmt.println ("Timed Out")
}

Tipp : time.After Sie context.WithTimeout .

Letzte Gedanken

Go's Concurrency -Modell geht weit über go und chan hinaus. Mit Bedacht verwendet:

• WaitGroup Fertigstellung.
• Mutex schützt den gemeinsamen Zustand.
• Context verwaltet Lebenszyklus und Stornierung.
• Once , Pool und atomic optimieren die Leistung und Korrektheit.

Sie ben?tigen nicht alle in jedem Programm - aber zu wissen, wann Sie für jeden greifen müssen, macht Ihren gleichzeitigen Go -Code robuster und effizienter.

Sobald Sie die ?Hello -Welt“ von Goroutines hinter sich haben, k?nnen Sie diese Primitiven erstellen, wenn Sie echte Systeme erstellen k?nnen.

Das obige ist der detaillierte Inhalt vonGehen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!