Corak Concurrency dalam Go: CSP lwn. Message Pass

Memahami dan menggunakan corak yang sesuai adalah penting apabila pengaturcaraan serentak dalam Go. CSP ialah mod konkurensi berdasarkan proses berjujukan, dilaksanakan menggunakan Goroutine, dan sesuai untuk komunikasi mudah. Hantaran mesej ialah corak yang menggunakan saluran sebagai baris gilir mesej untuk komunikasi, dan sesuai untuk senario interaksi Goroutine yang kompleks atau berbilang. Dalam aplikasi praktikal, CSP boleh digunakan untuk melaksanakan perkhidmatan mesej ringkas, menghantar dan menerima mesej antara Goroutine yang berbeza melalui saluran.

Corak Concurrency dalam Go: CSP lwn. Message Passing

Apabila pengaturcaraan serentak dalam Go, adalah penting untuk memahami dan menggunakan corak yang sesuai. Proses Berjujukan Berkomunikasi (CSP) dan penghantaran mesej ialah dua corak serentak biasa dalam Go yang menyediakan cara berbeza untuk menyelaraskan operasi serentak dengan cekap.

CSP

CSP ialah mod serentak berdasarkan proses berurutan yang melakukan operasi hantar dan terima secara bergilir-gilir. Go mempunyai Goroutines terbina dalam, menjadikan corak CSP sebagai pilihan yang ringkas dan berkuasa.

package main

import "fmt"

func main() {
    ch := make(chan int)
    go func() {
        ch <- 42
    }()
    fmt.Println(<-ch)
}

Dalam contoh ini, Goroutine bertanggungjawab untuk menghantar integer ke saluran ch dan Goroutine utama menerima integer daripada saluran. ch 发送一个整数，而主 Goroutine 从通道中接收该整数。

消息传递

消息传递是另一种用于在并发进程之间进行通信的模式。Go 中的通道本质上是消息队列，允许 Goroutine 安全且有效地交换数据。

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    ch := make(chan string)
    wg.Add(1)
    go func() {
        defer wg.Done()
        ch <- "Hello"
    }()
    wg.Wait()
    fmt.Println(<-ch)
}

在这个示例中，一个额外的 sync.WaitGroup 用于同步不同 Goroutine 的执行。Goroutine 将字符串消息发送到通道 ch

Pemesejan

Pemesejan ialah satu lagi corak yang digunakan untuk komunikasi antara proses serentak. Saluran dalam Go pada asasnya ialah baris gilir mesej yang membolehkan Goroutines menukar data dengan selamat dan cekap.

package main

import (
    "fmt"
    "sync"
)

type Message struct {
    From, To, Content string
}

func main() {
    ch := make(chan Message)
    var wg sync.WaitGroup
    wg.Add(2)

    go func() {
        defer wg.Done()
        senderMessages(ch)
    }()

    go func() {
        defer wg.Done()
        receiveMessages(ch)
    }()

    wg.Wait()
}

func senderMessages(ch chan Message) {
    ch <- Message{From: "John", To: "Jane", Content: "Hello"}
    ch <- Message{From: "Jane", To: "John", Content: "Hi"}
}

func receiveMessages(ch chan Message) {
    for msg := range ch {
        fmt.Println(msg)
    }
}

Dalam contoh ini, sync.WaitGroup tambahan digunakan untuk menyegerakkan pelaksanaan Goroutine yang berbeza. Goroutine menghantar mesej rentetan ke saluran ch dan Goroutine utama menerima mesej daripada saluran.

• Bila menggunakan setiap mod

Pilihan untuk menggunakan CSP atau pemesejan bergantung pada keperluan aplikasi:

Gunakan CSP untuk komunikasi mudah di mana Goroutine tunggal menghantar dan menerima data.

Gunakan pemesejan untuk komunikasi yang lebih kompleks, di mana berbilang Goroutine berinteraksi dengan medium komunikasi yang dikongsi (iaitu saluran).

🎜Amalan🎜🎜🎜Contoh praktikal ialah menggunakan CSP untuk melaksanakan perkhidmatan pemesejan mudah: 🎜rrreee🎜Contoh ini menunjukkan cara menggunakan corak CSP untuk menghantar dan menerima mesej antara Goroutine yang berbeza. 🎜

Atas ialah kandungan terperinci Corak Concurrency dalam Go: CSP lwn. Message Pass. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!