Mengelakkan keadaan perlumbaan dalam komunikasi saluran paip fungsi golang

Selesaikan keadaan perlumbaan dalam komunikasi saluran paip fungsi: gunakan jenis selamat serentak (sync.Mutex) untuk menyegerakkan akses kepada data saluran paip. Tambahkan penimbalan pada saluran paip untuk menyimpan data buat sementara waktu dan mengelakkan perbalahan data antara goroutine. Hadkan bilangan goroutine yang melaksanakan saluran paip fungsi secara serentak, memaksa pelaksanaan bersiri.

Mengelakkan keadaan perlumbaan dalam komunikasi saluran paip fungsi bahasa Go

Intipati komunikasi saluran paip serentak

Dalam bahasa Go, saluran paip ialah mekanisme yang digunakan untuk komunikasi antara gorouti. Mereka sememangnya selamat bersamaan, bermakna terdapat berbilang goroutin membaca dan menulis ke paip pada masa yang sama.

Keadaan Perlumbaan

Walau bagaimanapun, apabila menggunakan saluran paip fungsi, keadaan perlumbaan mungkin timbul. Ini merujuk kepada tingkah laku yang tidak dijangka yang boleh berlaku apabila berbilang goroutine melaksanakan saluran paip fungsi secara serentak. Khususnya, ia boleh menyebabkan pesanan keluaran yang tidak dijangka atau kehilangan data. . Ini menghalang keadaan perlumbaan dengan membenarkan hanya satu goroutine mengakses data pada satu masa.

package main

import (
    "sync"
)

func main() {
    var m sync.Mutex
    numbers := make([]int, 10)

    for i := 0; i < 10; i++ {
        go func(i int) {
            m.Lock()
            defer m.Unlock()

            numbers[i] = i * i
        }(i)
    }

    // 等待所有goroutine完成
}

Menggunakan penimbalan saluran

Dengan menambahkan penimbalan pada saluran paip, kami boleh menyimpan data buat sementara waktu dan menghalang perbalahan data antara goroutine.

package main

func main() {
    // 创建一个通道，缓冲为 1
    numbers := make(chan int, 1)

    for i := 0; i < 10; i++ {
        go func(i int) {
            // 写入通道，由于通道缓冲为 1，因此最多会有一个goroutine在写入
            numbers <- i * i
        }(i)
    }

    // 从通道中读取
    for i := 0; i < 10; i++ {
        fmt.Println(<-numbers)
    }
}

Hadkan bilangan goroutin

Dengan mengehadkan bilangan goroutin yang boleh melaksanakan saluran paip fungsi pada masa yang sama, kita boleh memaksa pelaksanaan bersiri dan dengan itu menghalang keadaan perlumbaan. sync.Mutex

package main

import (
    "context"
    "sync"
)

func main() {
    // 创建带有并发限制 1 的goroutine池
    pool, _ := context.WithCancel(context.Background())
    poolSize := 1

    wg := sync.WaitGroup{}

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            // 限制goroutine池中的并发执行数量
            _ = pool.Err()

            // 访问管道数据
        }
    }
}

Dengan menggunakan teknik ini, kami boleh memintas keadaan perlumbaan dalam saluran paip berfungsi dan memastikan kebolehpercayaan dan ketepatan operasi serentak.

Atas ialah kandungan terperinci Mengelakkan keadaan perlumbaan dalam komunikasi saluran paip fungsi golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!