Mekanisme komunikasi coroutine Golang

Go coroutine berkomunikasi melalui saluran (menghantar dan menerima data) dan primitif penyegerakan (menguruskan akses kepada sumber yang dikongsi). Saluran digunakan untuk memindahkan data antara coroutine melalui operasi hantar dan terima. Primitif penyegerakan termasuk kunci mutex (untuk mengawal akses kepada sumber yang dikongsi), pembolehubah keadaan (untuk menunggu syarat dipenuhi sebelum meneruskan pelaksanaan), dan isyarat sekali (untuk memastikan operasi dilakukan sekali sahaja).

Go mekanisme komunikasi coroutine

Apakah coroutine?

Coroutine ialah utas ringan yang membenarkan pelaksanaan serentak tanpa membuat urutan sistem yang berasingan. Ia menyediakan cara pengaturcaraan serentak yang lebih cekap dan menjimatkan sumber.

Mekanisme komunikasi

Go coroutine boleh berkomunikasi melalui dua mekanisme berikut:

• Saluran: Saluran tidak terbuffer atau tertimbal digunakan untuk menghantar dan menerima data.
• Primitif penyegerakan: seperti kunci mutex, pembolehubah keadaan dan isyarat sekali, digunakan untuk mengurus akses serentak kepada sumber yang dikongsi.

Saluran

Saluran ialah mekanisme komunikasi segerak yang menyediakan dua operasi:

• chan: Hantar nilai <code>v ke lorong. chan：将值 <code>v 发送到通道。
• ：从通道接收值。

以下示例演示如何使用管道在两个协程之间传递消息：

package main

import (
    "fmt"
    "sync"
)

func main() {
    // 创建一个无缓冲管道
    message := make(chan string)

    // 启动一个发送协程
    go func() {
        // 向通道发送消息
        message <- "Hello from the sending goroutine!"
    }()

    // 启动一个接收协程
    go func() {
        // 从通道接收消息
        msg := <-message
        fmt.Println(msg) // 输出: Hello from the sending goroutine!
    }()

    // 等待协程完成
    var wg sync.WaitGroup
    wg.Add(2)
    wg.Wait()
}

同步原语

同步原语可用于协调对共享资源的访问。以下是一些常用的同步原语：

• 互斥锁（sync.Mutex）：允许一次只有一个协程访问共享资源。
• 条件变量（sync.Cond）：用于等待某个条件满足后再继续执行。
• 一次性信号（sync.Once: Terima nilai daripada saluran.

Contoh berikut menunjukkan cara menggunakan paip untuk menghantar mesej antara dua coroutine:

package main

import (
    "fmt"
    "sync"
)

var counter int
var mu sync.Mutex

func main() {
    // 启动多个协程同时对共享变量进行加法
    var wg sync.WaitGroup
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func() {
            mu.Lock()
            counter++
            mu.Unlock()
            wg.Done()
        }()
    }

    wg.Wait()
    fmt.Println(counter) // 输出: 100
}

Primitif Penyegerakan 🎜🎜🎜Primitif penyegerakan boleh digunakan untuk menyelaraskan akses kepada sumber yang dikongsi. Berikut ialah beberapa primitif penyegerakan yang biasa digunakan: 🎜🎜🎜🎜Kunci mutex (sync.Mutex): 🎜Membenarkan hanya satu coroutine mengakses sumber yang dikongsi pada satu masa. 🎜🎜🎜Pembolehubah keadaan (sync.Cond): 🎜Digunakan untuk menunggu syarat tertentu dipenuhi sebelum meneruskan pelaksanaan. 🎜🎜🎜Isyarat sekali (segerakkan.Sekali): 🎜Memastikan operasi hanya dilaksanakan sekali. 🎜🎜🎜Contoh berikut menunjukkan cara menggunakan mutex untuk melindungi akses kepada sumber yang dikongsi: 🎜rrreee🎜Memahami mekanisme komunikasi coroutine Go adalah penting untuk membangunkan aplikasi serentak yang cekap dan berskala. 🎜

Atas ialah kandungan terperinci Mekanisme komunikasi coroutine Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!