Golangs Kanal ist eine Schlüsselkomponente seines CSP-Parallelitätsmodells und eine Brücke für die Kommunikation zwischen Goroutinen. Channel wird in Golang häufig verwendet und es ist wichtig, ein tiefes Verständnis seiner internen Implementierungsprinzipien zu haben. In diesem Artikel wird die zugrunde liegende Implementierung von Channel basierend auf dem Go 1.13-Quellcode analysiert.
Bevor wir die Implementierung von Channel offiziell analysieren, werfen wir einen Blick auf seine grundlegende Verwendung:
<code class="language-go">package main
import "fmt"
func main() {
c := make(chan int)
go func() {
c <- 1 // 发送操作
}()
x := <-c // 接收操作
fmt.Println(x)
}</code>Dieser Code zeigt zwei grundlegende Operationen von Channel:
c <- 1
x := <-c
Der Kanal ist in gepufferten Kanal und nicht gepufferten Kanal unterteilt. Der obige Code verwendet einen nicht gepufferten Kanal. Wenn in einem nicht gepufferten Kanal derzeit keine andere Goroutine Daten empfängt, blockiert der Absender die Sendeanweisung.
Sie können die Puffergröße beim Initialisieren des Kanals angeben. Beispielsweise gibt make(chan int, 2) die Puffergröße auf 2 an. Bevor der Puffer voll ist, kann der Sender Daten ohne Blockierung senden, ohne darauf warten zu müssen, dass der Empfänger bereit ist. Wenn der Puffer jedoch voll ist, blockiert der Absender trotzdem.
Bevor Sie in den Channel-Quellcode eintauchen, müssen Sie den spezifischen Implementierungsort von Channel in Golang finden. Bei Verwendung von Channel werden tatsächlich die zugrunde liegenden Funktionen wie runtime.makechan, runtime.chansend und runtime.chanrecv aufgerufen.
Sie können den Befehl go tool compile -N -l -S hello.go verwenden, um den Code in Montageanweisungen umzuwandeln, oder das Online-Tool Compiler Explorer verwenden (zum Beispiel: go.godbolt.org/z/3xw5Cj). Durch die Analyse der Montageanleitung können wir Folgendes finden:
make(chan int) entspricht der Funktion runtime.makechan. c <- 1 entspricht der Funktion runtime.chansend. x := <-c entspricht der Funktion runtime.chanrecv. Die Implementierung dieser Funktionen befindet sich in der runtime/chan.go-Datei des Go-Quellcodes.
make(chan int) wird vom Compiler in eine runtime.makechan-Funktion umgewandelt und ihre Funktionssignatur lautet wie folgt:
<code class="language-go">func makechan(t *chantype, size int) *hchan</code>
Unter diesen ist t *chantype der Kanalelementtyp, size int die vom Benutzer angegebene Puffergröße (0, wenn nicht angegeben) und der Rückgabewert ist *hchan. hchan ist die interne Implementierungsstruktur von Channel in Golang, definiert wie folgt:
<code class="language-go">type hchan struct {
qcount uint // 缓冲区中已放入元素的数量
dataqsiz uint // 用户构造Channel时指定的缓冲区大小
buf unsafe.Pointer // 缓冲区
elemsize uint16 // 缓冲区中每个元素的大小
closed uint32 // Channel是否关闭，==0表示未关闭
elemtype *_type // Channel元素的类型信息
sendx uint // 缓冲区中发送元素的索引位置（发送索引）
recvx uint // 缓冲区中接收元素的索引位置（接收索引）
recvq waitq // 等待接收的Goroutine列表
sendq waitq // 等待发送的Goroutine列表
lock mutex
}</code>Die Attribute in hchan sind grob in drei Kategorien unterteilt:
buf, dataqsiz, qcount usw. Wenn die Puffergröße des Kanals nicht 0 ist, wird der Puffer zum Speichern der zu empfangenden Daten verwendet und mithilfe eines Ringpuffers implementiert. recvq enthält Goroutine, die auf den Empfang von Daten wartet, sendq enthält Goroutine, die auf das Senden von Daten wartet. waitqImplementiert mithilfe einer doppelt verknüpften Liste. lock, elemtype, closed usw. makechan führt hauptsächlich einige Legalitätsprüfungen und Speicherzuweisungen von Attributen wie Puffern und hchan durch, auf die hier nicht näher eingegangen wird.
Anhand einer einfachen Analyse des hchan-Attributs ist ersichtlich, dass es zwei wichtige Komponenten gibt: Puffer und Warteschlange. Alle Verhaltensweisen und Implementierungen von hchan drehen sich um diese beiden Komponenten.
Die Sende- und Empfangsprozesse von Channel sind sehr ähnlich. Analysieren Sie zunächst den Sendevorgang des Kanals (z. B. c <- 1).
versucht, Daten an den Kanal zu senden und die recvq-Warteschlange nicht leer ist, wird eine Goroutine, die auf den Empfang von Daten wartet, aus dem recvq-Header entnommen und die Daten werden direkt an die Goroutine gesendet. Der Code lautet wie folgt:
<code class="language-go">package main
import "fmt"
func main() {
c := make(chan int)
go func() {
c <- 1 // 发送操作
}()
x := <-c // 接收操作
fmt.Println(x)
}</code>recvq Enthält Goroutine, die auf den Empfang von Daten wartet. Wenn eine Goroutine eine Empfangsoperation verwendet (z. B. x := <-c) und sendq zu diesem Zeitpunkt nicht leer ist, wird eine Goroutine von sendq übernommen und die Daten werden an sie gesendet.
Wenn recvq leer ist, bedeutet dies, dass zu diesem Zeitpunkt keine Goroutine auf den Empfang von Daten wartet und der Kanal versucht, die Daten in den Puffer zu legen:
<code class="language-go">func makechan(t *chantype, size int) *hchan</code>
Die Funktion dieses Codes ist sehr einfach, er besteht darin, Daten in den Puffer zu legen. Dieser Prozess beinhaltet den Betrieb eines Ringpuffers. dataqsiz stellt die vom Benutzer angegebene Puffergröße dar (standardmäßig 0, wenn nicht angegeben).
Wenn ein nicht gepufferter Kanal verwendet wird oder der Puffer voll ist (c.qcount == c.dataqsiz), werden die zu sendenden Daten und die aktuelle Goroutine in ein sudog-Objekt gepackt, in sendq platziert und im aktuellen Goroutine wird auf Wartestatus eingestellt:
<code class="language-go">type hchan struct {
qcount uint // 缓冲区中已放入元素的数量
dataqsiz uint // 用户构造Channel时指定的缓冲区大小
buf unsafe.Pointer // 缓冲区
elemsize uint16 // 缓冲区中每个元素的大小
closed uint32 // Channel是否关闭，==0表示未关闭
elemtype *_type // Channel元素的类型信息
sendx uint // 缓冲区中发送元素的索引位置（发送索引）
recvx uint // 缓冲区中接收元素的索引位置（接收索引）
recvq waitq // 等待接收的Goroutine列表
sendq waitq // 等待发送的Goroutine列表
lock mutex
}</code>goparkunlock entsperrt den Eingabe-Mutex, unterbricht die aktuelle Goroutine und versetzt sie in einen Wartezustand. gopark und goready erscheinen paarweise und sind reziproke Operationen.
Aus Sicht des Benutzers wird nach dem Aufruf von gopark die Codeanweisung zum Senden von Daten blockiert.
Der Empfangsprozess von Channel ähnelt im Wesentlichen dem Sendeprozess, daher werde ich hier nicht auf Details eingehen. Die am Empfangsprozess beteiligten pufferbezogenen Vorgänge werden später ausführlich beschrieben.
Es ist zu beachten, dass der gesamte Sende- und Empfangsprozess des Kanals mit runtime.mutex gesperrt ist. runtime.mutex ist eine leichte Sperre, die häufig in laufzeitbezogenem Quellcode verwendet wird. Der gesamte Prozess ist nicht die effizienteste sperrenfreie Lösung. Es gibt ein Problem mit dem sperrfreien Kanal in Golang: go/issues#8899.
Der Kanal verwendet einen Ringpuffer, um geschriebene Daten zwischenzuspeichern. Ringpuffer haben viele Vorteile und eignen sich ideal für die Implementierung von FIFO-Warteschlangen fester Länge.
Die Implementierung des Ringpuffers im Kanal ist wie folgt:
Inhchan gibt es zwei pufferbezogene Variablen: recvx und sendx. sendx stellt einen beschreibbaren Index im Puffer dar und recvx stellt einen lesbaren Index im Puffer dar. Elemente zwischen recvx und sendx stellen Daten dar, die normal in den Puffer gelegt wurden.
Sie können buf[recvx] direkt verwenden, um das erste Element der Warteschlange zu lesen, und buf[sendx] = x verwenden, um das Element am Ende der Warteschlange zu platzieren.
Wenn der Puffer nicht voll ist, erfolgt das Einfügen von Daten in den Puffer wie folgt:
<code class="language-go">package main
import "fmt"
func main() {
c := make(chan int)
go func() {
c <- 1 // 发送操作
}()
x := <-c // 接收操作
fmt.Println(x)
}</code>chanbuf(c, c.sendx) entspricht c.buf[c.sendx]. Der obige Vorgang ist sehr einfach. Kopieren Sie einfach die Daten in den Pufferspeicherort sendx.
Dann bewegen Sie sendx zur nächsten Position. Wenn sendx die letzte Position erreicht, wird sie auf 0 gesetzt, was einem typischen End-to-End-Ansatz entspricht.
Wenn der Puffer nicht voll ist, muss sendq auch leer sein (denn wenn der Puffer nicht voll ist, wird die Goroutine, die die Daten sendet, nicht in die Warteschlange gestellt, sondern legt die Daten direkt in den Puffer). Zu diesem Zeitpunkt ist die Leselogik von Kanal chanrecv relativ einfach. Daten können direkt aus dem Puffer gelesen werden. Es handelt sich auch um einen Prozess zum Verschieben von recvx, der im Grunde derselbe ist wie das oben beschriebene Pufferschreiben.
Wenn in sendq eine Goroutine wartet, muss der Puffer zu diesem Zeitpunkt voll sein. Zu diesem Zeitpunkt lautet die Leselogik von Channel wie folgt:
<code class="language-go">func makechan(t *chantype, size int) *hchan</code>
ep ist die Adresse, die der Variablen entspricht, die die Daten empfängt (in x := <-c ist ep beispielsweise die Adresse von x). sg stellt das erste sendq aus sudog dar. Im Code:
typedmemmove(c.elemtype, ep, qp) bedeutet das Kopieren des aktuell lesbaren Elements im Puffer an die Adresse der empfangenden Variablen. typedmemmove(c.elemtype, qp, sg.elem) bedeutet, dass die Daten, die darauf warten, von Goroutine gesendet zu werden, in sendq in den Puffer kopiert werden. Da recv später ausgeführt wird, entspricht dies dem Platzieren der Daten in sendq am Ende der Warteschlange. Einfach ausgedrückt kopiert der Kanal hier die ersten Daten im Puffer in die entsprechende Empfangsvariable und kopiert gleichzeitig die Elemente in sendq an das Ende der Warteschlange, wodurch FIFO (First In, First Out) implementiert wird. .
Channel ist eine der am häufigsten genutzten Funktionen in Golang. Wenn Sie den Quellcode kennen, können Sie Channel besser nutzen und verstehen. Seien Sie gleichzeitig nicht zu abergläubisch und verlassen Sie sich auf die Leistung von Channel. Das aktuelle Design von Channel bietet noch viel Raum für Optimierung.
Optimierungsvorschläge:
Abschließend empfehle ich eine Plattform, die sich sehr gut für die Bereitstellung von Go-Diensten eignet: Leapcell
Weitere Informationen finden Sie in der Dokumentation!
Leapcell Twitter: https://www.php.cn/link/7884effb9452a6d7a7a79499ef854afd
Das obige ist der detaillierte Inhalt vonGo Channel Unlocked: So funktionieren sie. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
Verbindung zurücksetzen Lösung
Win10 taskmgr.exe-Dateianwendungsfehlerlösung
Excel-Tabellen-Schrägstrich in zwei Teile geteilt
Tool zur Abfrage von Website-Subdomains
So öffnen Sie HTML-Dateien auf dem iPad
So springen Sie mit Parametern in vue.js
So zeigen Sie Prozesse unter Linux an
So lösen Sie die Zeitüberschreitung
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
