Typen und Regeln von Kanälen in Golang funktionieren bei der gleichzeitigen Programmierung

Channel ist ein Kommunikationsmechanismus in der Go-Sprache zum sicheren Übertragen von Daten zwischen gleichzeitigen Funktionen. Er bietet Schutz vor Datenrennen, um den direkten Zugriff auf den gemeinsam genutzten Speicher zu vermeiden. Zu den Kanaltypen gehören ungepufferter Kanal (chan T) und gepufferter Kanal (chan T, int). Zu den Regeln gehören das Senden eines Werts (

Kanaltypen und Regeln bei der gleichzeitigen Programmierung von Go-Sprachfunktionen

Kanäle sind ein Kommunikationsmechanismus in der Go-Sprache zum sicheren Übertragen von Daten zwischen gleichzeitigen Funktionen. Sie bieten eine Abstraktionsebene, die den direkten Zugriff von Funktionen auf den gemeinsamen Speicher überflüssig macht und so Datenwettläufe vermeidet.

Kanaltypen

• Ungepufferter Kanal (Chan T): Dieser Kanaltyp hat keinen internen Puffer, daher müssen Sender und Empfänger gleichzeitig zur Kommunikation bereit sein.
• Gepufferter Kanal (chan T, int): Dieser Kanaltyp verfügt über einen internen Puffer einer bestimmten Größe zum Speichern von Werten. Es ermöglicht dem Sender, einen Wert zu senden, wenn der Empfänger nicht bereit ist, ihn zu empfangen, und umgekehrt.

Kanalregeln

• Senden Sie einen Wert: Verwenden Sie den send-Operator (), um einen Wert an einen Kanal zu senden. Der Kanal muss mit <code> gesperrt werden, bevor ein Wert gesendet werden kann. <code>send 操作符 () 将值发送到通道。必须先使用 <code> 锁定通道，然后再发送值。
• 接收值：使用 receive 操作符 (->) 从通道接收值。与发送值类似，必须先使用 chan 锁定通道，然后再接收值。
• 关闭通道：使用 close(chan) 关闭通道。关闭后，无法再向通道发送值，但可以继续接收已发送的值。
• 通道容量：缓冲通道有一个指定的最大容量，由创建时指定的第二个参数确定。如果通道已满，发送方将阻塞，直到有空间可用。
• 选择：select 语句允许从多个通道进行选择性接收或发送。它提供了事件驱动的并发编程模型。

实战案例

考虑一个计算素数的程序：

package main

import (
    "fmt"
    "math"
    "sync"
    "time"
)

// 工作单元
type WorkUnit struct {
    n        uint64
    isPrime  bool
    finished chan bool
}

// 素数计算函数
func isPrime(n uint64) bool {
    if n <= 1 {
        return false
    }
    for i := uint64(2); i <= uint64(math.Sqrt(float64(n))); i++ {
        if n%i == 0 {
            return false
        }
    }
    return true
}

// 工作器函数
func worker(in, out chan *WorkUnit, wg *sync.WaitGroup) {
    defer wg.Done()
    for unit := range in {
        unit.isPrime = isPrime(unit.n)
        close(unit.finished)
        out <- unit
    }
}

func main() {
    // 输入通道
    in := make(chan *WorkUnit)
    // 输出通道
    out := make(chan *WorkUnit)

    // 初始化工作单元
    units := make([]*WorkUnit, 500000)
    for i := range units {
        units[i] = &WorkUnit{
            n:        uint64(i),
            finished: make(chan bool),
        }
    }

    // 启动工作器
    wg := &sync.WaitGroup{}
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go worker(in, out, wg)
    }

    // 将工作单元推送到输入通道
    start := time.Now()
    for _, unit := range units {
        in <- unit
    }
    close(in)

    // 从输出通道接收结果
    for unit := range out {
        <-unit.finished
    }
    elapsed := time.Since(start)

    fmt.Printf("Took %s\n", elapsed)
}

在这个示例中：

• in 通道是无缓冲通道，用于将工作单元发送到工作器函数。
• out 通道是缓冲通道，用于将计算结果传回主函数。
• finished

Wert empfangen:

Verwenden Sie den Operator receive (->), um einen Wert von einem Kanal zu empfangen. Ähnlich wie beim Senden von Werten muss der Kanal vor dem Empfangen von Werten mit chan gesperrt werden.

🎜🎜Kanal schließen: 🎜Verwenden Sie close(chan), um den Kanal zu schließen. Nach dem Schließen können keine Werte mehr an den Kanal gesendet werden, bereits gesendete Werte können jedoch weiterhin empfangen werden. 🎜🎜🎜Kanalkapazität: 🎜Pufferkanäle haben eine angegebene maximale Kapazität, die durch den zweiten Parameter bestimmt wird, der beim Erstellen angegeben wird. Wenn der Kanal voll ist, blockiert der Absender, bis Platz frei wird. 🎜🎜🎜Select: Die 🎜select-Anweisung ermöglicht das selektive Empfangen oder Senden von mehreren Kanälen. Es bietet ein ereignisgesteuertes Modell für die gleichzeitige Programmierung. 🎜🎜🎜🎜Praktisches Beispiel🎜🎜🎜Stellen Sie sich ein Programm vor, das Primzahlen berechnet: 🎜rrreee🎜In diesem Beispiel: 🎜🎜🎜in-Kanal ist ein ungepufferter Kanal, der zum Senden von Arbeitseinheiten an die Worker-Funktion verwendet wird. 🎜🎜out-Kanal ist ein Pufferkanal, der verwendet wird, um Berechnungsergebnisse zurück an die Hauptfunktion zu übertragen. 🎜🎜Der Kanal fertig ist ein ungepufferter Kanal, der der Hauptfunktion signalisiert, nachdem die Arbeitsfunktion ihre Berechnung abgeschlossen hat. 🎜🎜🎜Dieses Programm zeigt, wie man Kanäle nutzt, um gleichzeitige Berechnungen in Go zu implementieren und dabei mehrere CPU-Kerne effektiv zu nutzen. 🎜

Das obige ist der detaillierte Inhalt vonTypen und Regeln von Kanälen in Golang funktionieren bei der gleichzeitigen Programmierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!