Was ist Goroutine in der Go-Sprache?

Goroutine ist eine leichtgewichtige Thread-Implementierung in der Go-Sprache. Es handelt sich um eine leichtgewichtige Abstraktion, die auf Threads basiert und von der Go-Laufzeit verwaltet wird. Mit Goroutine können wir im Vergleich zu Threads zu sehr geringen Kosten mehrere Funktionen oder Methoden parallel im selben Adressraum ausführen, ihre Erstellung und Zerstörung ist viel kostengünstiger und ihre Planung erfolgt unabhängig von Threads.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, GO Version 1.18, Dell G3-Computer.

Wenn Sie ein Socket-Netzwerkprogramm schreiben, müssen Sie im Voraus einen Thread-Pool vorbereiten, um jedem Socket, der Pakete sendet und empfängt, einen Thread zuzuweisen. Entwickler müssen eine entsprechende Beziehung zwischen der Anzahl der Threads und der Anzahl der CPUs herstellen, um sicherzustellen, dass jede Aufgabe der CPU rechtzeitig zur Verarbeitung zugewiesen werden kann, und gleichzeitig den Effizienzverlust vermeiden, der durch den häufigen Wechsel mehrerer Aufgaben zwischen Threads verursacht wird .

Obwohl der Thread-Pool einen abstrakten Mechanismus für die Thread-Zuweisung für Logikschreiber bietet. Angesichts der Anforderungen an Parallelität und Thread-Verarbeitung, die jederzeit und überall auftreten können, ist der Thread-Pool jedoch nicht sehr intuitiv und praktisch. Gibt es einen Mechanismus: Wenn der Benutzer genügend Aufgaben zuweist, kann das System dem Benutzer automatisch helfen, die Aufgaben der CPU zuzuweisen, damit diese Aufgaben so gleichzeitig wie möglich ausgeführt werden können. Dieser Mechanismus wird in der Go-Sprache Goroutine genannt.

goroutine ist eine leichtgewichtige Thread-Implementierung in der Go-Sprache und wird von der Go-Laufzeit verwaltet. Go-Programme weisen jeder CPU intelligent Aufgaben in Goroutinen zu.

Goroutine ist eine leichte Abstraktion, die auf Threads basiert. Es ermöglicht uns, mehrere Funktionen oder Methoden zu sehr geringen Kosten parallel im selben Adressraum auszuführen. Im Vergleich zu Threads ist die Erstellung und Zerstörung wesentlich kostengünstiger und die Planung erfolgt unabhängig von Threads.

Das Go-Programm startet mit der main()-Funktion des Hauptpakets. Wenn das Programm startet, erstellt das Go-Programm eine Standard-Goroutine für die main()-Funktion.

Verwenden Sie gewöhnliche Funktionen, um eine Goroutine zu erstellen.

Verwenden Sie das Schlüsselwort go im Go-Programm, um eine Goroutine für eine Funktion zu erstellen. Eine Funktion kann mit mehreren Goroutinen erstellt werden, und eine Goroutine muss einer Funktion entsprechen.

1) Format

Das Erstellen einer Goroutine für eine gemeinsame Funktion wird wie folgt geschrieben:

go 函数名( 参数列表 )

• Funktionsname: der Name der aufzurufenden Funktion.

• Parameterliste: Parameter, die beim Aufruf der Funktion übergeben werden müssen.

Wenn Sie das Schlüsselwort go zum Erstellen einer Goroutine verwenden, wird der Rückgabewert der aufgerufenen Funktion ignoriert.

Wenn Sie Daten in Goroutine zurückgeben müssen, verwenden Sie bitte die später eingeführte Kanalfunktion, um die Daten von Goroutine als Rückgabewert über den Kanal weiterzugeben.

2) Beispiel

Verwenden Sie das Schlüsselwort go, um die Funktion „running()“ gleichzeitig auszuführen und dabei jede Sekunde einen Zähler zu drucken, während die Haupt-Goroutine auf Benutzereingaben wartet und die beiden Aktionen gleichzeitig ausgeführt werden können. Bitte beachten Sie den folgenden Code:

package main
import (
    "fmt"
    "time"
)
func running() {
    var times int
    // 构建一个无限循环
    for {
        times++
        fmt.Println("tick", times)
        // 延时1秒
        time.Sleep(time.Second)
    }
}
func main() {
    // 并发执行程序
    go running()
    // 接受命令行输入, 不做任何事情
    var input string
    fmt.Scanln(&input)
}

Die Befehlszeilenausgabe lautet wie folgt:

Nachdem der Code ausgeführt wurde, gibt die Befehlszeile kontinuierlich Ticks aus und Sie können fmt.Scanln() verwenden, um Benutzereingaben zu akzeptieren . Beide Schritte können gleichzeitig durchgeführt werden.

Die Codebeschreibung lautet wie folgt:

• Zeile 12, verwenden Sie for, um eine Endlosschleife zu bilden.

• Zeile 13, die Zeitvariable steigt in der Schleife weiter an.

• Zeile 14, Ausgabe des Werts der Times-Variablen.

• Zeile 17, nutzen Sie time.Sleep, um eine Sekunde lang zu pausieren und dann mit der Schleife fortzufahren.

• Zeile 25: Verwenden Sie das Schlüsselwort go, um die Funktion running() gleichzeitig laufen zu lassen.

• Zeile 29, akzeptieren Sie Benutzereingaben, bis die Eingabetaste gedrückt wird, der Eingabeinhalt in die Eingabevariable geschrieben und zurückgegeben wird und das gesamte Programm beendet wird.

Die Ausführungssequenz dieses Codes ist in der folgenden Abbildung dargestellt.

Abbildung: Gleichzeitiges Laufdiagramm

In diesem Beispiel erstellt die Laufzeit (Runtime) beim Start des Go-Programms standardmäßig eine Goroutine für die Funktion main(). Wenn die Go-Running-Anweisung in der Goroutine der Funktion main() ausgeführt wird, wird die zur Funktion Running() gehörende Goroutine erstellt und die Funktion Running() beginnt mit der Ausführung in ihrer eigenen Goroutine. Zu diesem Zeitpunkt wird main() weiterhin ausgeführt und die beiden Goroutinen arbeiten gleichzeitig über den Planungsmechanismus des Go-Programms.

Erstellen Sie eine Goroutine mit einer anonymen Funktion.

Sie können auch eine Goroutine für eine anonyme Funktion oder einen Abschluss nach dem Schlüsselwort „go“ starten.

1) Das Format der Verwendung anonymer Funktionen zum Erstellen von Goroutinen

Wenn Sie anonyme Funktionen oder Abschlüsse zum Erstellen von Goroutinen verwenden, müssen Sie neben dem Schreiben des Funktionsdefinitionsteils nach Go auch die Aufrufparameter der anonymen Funktion hinzufügen , das Format ist wie folgt:

go func( 参数列表 ){
    函数体
}( 调用参数列表 )

Wo:

• Parameterliste: Die Liste der Parametervariablen im Funktionskörper.

• Funktionskörper: der Code der anonymen Funktion.

• 调用参数列表：启动 goroutine 时，需要向匿名函数传递的调用参数。

2) 使用匿名函数创建goroutine的例子

在 main() 函数中创建一个匿名函数并为匿名函数启动 goroutine。匿名函数没有参数。代码将并行执行定时打印计数的效果。参见下面的代码：

package main
import (
    "fmt"
    "time"
)
func main() {
    go func() {
        var times int
        for {
            times++
            fmt.Println("tick", times)
            time.Sleep(time.Second)
        }
    }()
    var input string
    fmt.Scanln(&input)
}

代码说明如下：

• 第 10 行，go 后面接匿名函数启动 goroutine。

• 第 12～19 行的逻辑与前面程序的 running() 函数一致。

• 第 21 行的括号的功能是调用匿名函数的参数列表。由于第 10 行的匿名函数没有参数，因此第 21 行的参数列表也是空的。

扩展知识：Goroutine与线程的区别

许多人认为goroutine比线程运行得更快，这是一个误解。Goroutine并不会更快，它只是增加了更多的并发性。当一个goroutine被阻塞（比如等待IO），golang的scheduler会调度其他可以执行的goroutine运行。与线程相比，它有以下的几个优点：

内存消耗更少：

Goroutine所需要的内存通常只有2kb，而线程则需要1Mb（500倍）

创建与销毁的开销更小：

由于线程创建时需要向操作系统申请资源，并且在销毁时将资源归还，因此它的创建和销毁的开销比较大。相比之下，goroutine的创建和销毁是由go语言在运行时自己管理的，因此开销更低。

切换开销更小：

只是goroutine之于线程的主要区别，也是golang能够实现高并发的主要原因。线程的调度方式是抢占式的，如果一个线程的执行时间超过了分配给它的时间片，就会被其他可执行的线程抢占。在线程切换的过程中需要保存/恢复所有的寄存器信息，比如16个通用寄存器，PC（Program Counter）、SP（Stack Pointer）段寄存器等等。而goroutine的调度是协同式的，它不会直接地与操作系统内核打交道。当goroutine进行切换的时候，之后很少量的寄存器需要保存和恢复（PC和SP）。因此goroutine的切换效率更高。

【相关推荐：Go视频教程、编程教学】

Das obige ist der detaillierte Inhalt vonWas ist Goroutine in der Go-Sprache?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!