Wie Golang-Funktionen mit Goroutine kommunizieren

Funktionen und Goroutinen können auf folgende Weise kommunizieren: Mutex-Sperre: Wird zum Schutz gemeinsam genutzter Ressourcen verwendet. Bedingungsvariable: Wird verwendet, um Goroutine zu benachrichtigen, wenn sie die Bedingung erfüllt. Kanal: Datenübertragungspuffer. Atomare Variable: Variable für den sperrfreien gleichzeitigen Zugriff. Praktischer Fall: parallele Verarbeitung von Aufgaben Verwenden Sie Goroutine, um die Ausführungseffizienz rechenintensiver Aufgaben zu verbessern. Dies umfasst drei Schritte: Aufgaben erstellen, Goroutine-Verarbeitungsaufgaben starten und Verarbeitungsergebnisse sammeln.

Die Kommunikationsmethode zwischen Funktionen und Goroutinen in der Go-Sprache

In der Go-Sprache können Funktionen und Goroutinen auf folgende Weise kommunizieren:

1. Mutex (Mutex)

Mutex-Sperren werden verwendet Schützen Sie gemeinsam genutzte Ressourcen und stellen Sie sicher, dass nur eine Goroutine gleichzeitig auf die Ressource zugreifen kann.

var mu sync.Mutex // 全局互斥锁 func increment(i *int) { mu.Lock() *i++ mu.Unlock() }

2. Bedingungsvariable (Cond)

Bedingungsvariable wird verwendet, um die wartende Goroutine zu benachrichtigen, wenn die angegebene Bedingung erfüllt ist.

var cond sync.Cond // 全局条件变量 func wait(c *sync.Cond, i *int) { c.L.Lock() for { if *i == 0 { c.Wait() } break } c.L.Unlock() }

3. Kanal

Ein Kanal ist ein Puffer, der zum Senden von Daten zwischen Goroutinen verwendet wird.

var ch = make(chan int, 10) // 创建容量为 10 的通道 func send(c chan int, i int) { c <- i // 发送数据 } func receive(c chan int) { v := <-c // 接收数据 }

4. Auf atomare Variablen kann gleichzeitig ohne Sperren zugegriffen werden.

var atomicInt int64 func incrementAtomic(i *int64) { atomicInt++ }

Praktischer Fall: Parallelverarbeitung von Aufgaben

Das Folgende ist ein praktischer Fall der Verwendung von Goroutine zur parallelen Verarbeitung von Aufgaben:

// 任务类型 type Task struct { Num int Chan chan int } func processTask(t *Task) { // 处理任务并返回结果 result := t.Num * t.Num t.Chan <- result } func createTasks(n int) []*Task { // 创建 n 个任务 tasks := make([]*Task, n) for i := 0; i < n; i++ { tasks[i] = &Task{ Num: i, Chan: make(chan int), } } return tasks } func main() { n := 10 tasks := createTasks(n) // 启动 n 个 Goroutine 并行处理任务 for _, t := range tasks { go processTask(t) } // 从任务中收集处理结果 results := make([]int, n) for i := 0; i < n; i++ { results[i] = <-tasks[i].Chan } // 打印结果 for _, r := range results { fmt.Println(r) } }

Das obige ist der detaillierte Inhalt vonWie Golang-Funktionen mit Goroutine kommunizieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!