Golang ist eine Programmiersprache, die sich durch Parallelität auszeichnet. Goroutine ist eine leichtgewichtige Thread-Implementierung, die Entwicklern helfen kann, gleichzeitige Aufgaben besser zu bewältigen. In Golang können Coroutinen in zwei Modi unterteilt werden: blockierend und nicht blockierend. Dieser Artikel befasst sich mit den Unterschieden zwischen Golang-Coroutinen im blockierenden und nicht blockierenden Modus und stellt spezifische Codebeispiele bereit, um den Lesern ein besseres Verständnis dieses Konzepts zu erleichtern.

1. Blockierungsmodus

Wenn eine Coroutine im Blockierungsmodus eine Blockierungsoperation ausführt, wird die gesamte Coroutine angehalten, bis die Operation abgeschlossen ist. Dies bedeutet, dass die Ausführung des Programms auf den Abschluss des Vorgangs wartet und nicht mit der Ausführung anderer Aufgaben fortfahren kann. Zu den üblichen Blockierungsvorgängen in Golang gehören E/A-Vorgänge, Netzwerkanforderungen usw.

Das Folgende ist ein Beispielcode, der den Blockierungsmodus verwendet:

package main

import (
    "fmt"
    "time"
)

func main() {
    go longRunningTask()
    time.Sleep(5 * time.Second)
}

func longRunningTask() {
    fmt.Println("开始执行长时间任务...")
    time.Sleep(10 * time.Second)
    fmt.Println("长时间任务执行完毕！")
}

Im obigen Beispiel ist die Funktion longRunningTask eine simulierte lange Aufgabe, die 10 Sekunden lang ruht. In der Funktion main haben wir eine Coroutine über das Schlüsselwort go gestartet, um die Funktion longRunningTask auszuführen, aber weil die Hauptcoroutine time aufgerufen hat .Sleep, um 5 Sekunden zu warten, sodass das gesamte Programm vor dem Ende 5 Sekunden lang blockiert wird. longRunningTask函数是一个模拟的长时间任务，它会休眠10秒钟。在main函数中，我们通过go关键字启动了一个协程来执行longRunningTask函数，但因为主协程调用了time.Sleep来等待5秒钟，所以整个程序会被阻塞5秒钟才会结束。

2. 非阻塞模式

相对于阻塞模式，非阻塞模式下的协程能够在执行一些任务的过程中遇到阻塞操作时，仍然能够继续处理其他任务，从而提高程序的并发性能。Golang中通过使用select语句和chan通道来实现非阻塞的任务调度。

以下是一个使用非阻塞模式的示例代码：

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan bool)
    go longRunningTask(ch)
    for {
        select {
        case <-ch:
            fmt.Println("长时间任务执行完毕！")
            return
        default:
            fmt.Println("在等待长时间任务完成时执行其他任务...")
            time.Sleep(1 * time.Second)
        }
    }
}

func longRunningTask(ch chan bool) {
    fmt.Println("开始执行长时间任务...")
    time.Sleep(10 * time.Second)
    fmt.Println("长时间任务执行完毕！")
    ch <- true
}

在上述示例中，我们使用了一个chan通道来通知主协程长时间任务已经执行完毕。在main函数中，我们启动了一个协程来执行longRunningTask函数，并通过select

2. Nicht blockierender Modus

Im Vergleich zum blockierenden Modus können Coroutinen im nicht blockierenden Modus weiterhin andere Aufgaben verarbeiten, wenn sie während der Ausführung einiger Aufgaben auf blockierende Vorgänge stoßen, wodurch die Parallelitätsleistung des Programms verbessert wird. Golang implementiert die nicht blockierende Aufgabenplanung mithilfe der select-Anweisung und des chan-Kanals.

Das Folgende ist ein Beispielcode im nicht blockierenden Modus:

rrreee

Im obigen Beispiel verwenden wir einen chan-Kanal, um die Haupt-Coroutine darüber zu informieren, dass die Langzeitaufgabe ausgeführt wurde. In der Funktion main starten wir eine Coroutine, um die Funktion longRunningTask auszuführen, und verwenden die Anweisung select, um zu bestimmen, ob die Aufgabe abgeschlossen wurde. Selbst während sie auf den Abschluss einer langen Aufgabe wartet, kann die Haupt-Coroutine weiterhin andere Aufgaben ausführen, ohne blockiert zu werden. 🎜🎜3. Zusammenfassung🎜🎜Anhand des obigen Beispielcodes können wir die spezifische Leistung des Blockierungsmodus und des Nichtblockierungsmodus in der Golang-Coroutine sehen. Der Blockierungsmodus führt dazu, dass das gesamte Programm angehalten wird, wenn Blockierungsvorgänge ausgeführt werden, während der nicht blockierende Modus die Parallelitätseigenschaften von Coroutinen voll ausnutzen kann, um eine gleichzeitige Ausführung mehrerer Aufgaben zu erreichen. 🎜🎜In tatsächlichen Anwendungen müssen Entwickler den geeigneten Modus basierend auf der Art und den Anforderungen der Aufgabe auswählen, um die Leistung und Parallelität des Programms zu optimieren. Durch ein tiefes Verständnis der blockierenden und nicht blockierenden Modi von Golang-Coroutinen können Sie die Parallelitätsfähigkeiten von Golang besser nutzen und die Effizienz und Leistung des Programms verbessern. 🎜

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