Jenis dan peraturan saluran dalam pengaturcaraan serentak fungsi Golang

Saluran ialah mekanisme komunikasi dalam bahasa Go untuk memindahkan data dengan selamat antara fungsi serentak Ia menyediakan perlindungan perlumbaan data untuk mengelakkan akses terus kepada memori yang dikongsi. Jenis saluran termasuk saluran tidak buffer (chan T) dan saluran buffered (chan T, int). Peraturan termasuk menghantar nilai (

Jenis dan peraturan saluran dalam pengaturcaraan serentak fungsi bahasa Go

Saluran ialah mekanisme komunikasi dalam bahasa Go untuk memindahkan data dengan selamat antara fungsi serentak. Mereka menyediakan lapisan abstraksi yang menghapuskan keperluan untuk fungsi untuk mengakses memori yang dikongsi secara langsung, dengan itu mengelakkan perlumbaan data.

Jenis Saluran

• Saluran Tanpa Penimbalan (chan T): Saluran jenis ini tidak mempunyai penimbal dalaman, jadi penghantar dan penerima mesti bersedia pada masa yang sama untuk berkomunikasi.
• Saluran penimbal (chan T, int): Saluran jenis ini mempunyai penimbal dalaman dengan saiz yang ditentukan untuk menyimpan nilai. Ia membolehkan penghantar menghantar nilai apabila penerima tidak bersedia untuk menerimanya, dan begitu juga sebaliknya.

Peraturan Saluran

• Hantar nilai: Gunakan operator hantar () untuk menghantar nilai ke saluran. Saluran mesti dikunci menggunakan <code> sebelum menghantar nilai. <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

Nilai terima:

Gunakan operator receive (->) untuk menerima nilai daripada saluran. Sama seperti menghantar nilai, saluran mesti dikunci menggunakan chan sebelum menerima nilai.

🎜🎜Tutup saluran: 🎜Gunakan close(chan) untuk menutup saluran. Selepas ditutup, tiada lagi nilai boleh dihantar ke saluran, tetapi nilai yang sudah dihantar boleh terus diterima. 🎜🎜🎜Kapasiti saluran: 🎜Saluran penimbal mempunyai kapasiti maksimum yang ditentukan, ditentukan oleh parameter kedua yang dinyatakan semasa membuat. Jika saluran penuh, penghantar menyekat sehingga ruang tersedia. 🎜🎜🎜Pilih: Penyataan 🎜pilih membenarkan penerimaan atau penghantaran terpilih daripada berbilang saluran. Ia menyediakan model pengaturcaraan serentak dipacu peristiwa. 🎜🎜🎜🎜Contoh Praktikal🎜🎜🎜Pertimbangkan program yang mengira nombor perdana: 🎜rrreee🎜Dalam contoh ini: 🎜🎜🎜 saluranin ialah saluran tidak buffer yang digunakan untuk menghantar unit kerja kepada pekerja. 🎜🎜 Saluranout ialah saluran penimbal yang digunakan untuk memindahkan hasil pengiraan kembali ke fungsi utama. 🎜🎜Saluran selesai ialah saluran tidak buffer yang digunakan untuk memberi isyarat kepada fungsi utama selepas fungsi pekerja menyelesaikan pengiraannya. 🎜🎜🎜Program ini menunjukkan cara menggunakan saluran untuk melaksanakan pengiraan serentak dalam Go, dengan berkesan menggunakan berbilang teras CPU. 🎜

Atas ialah kandungan terperinci Jenis dan peraturan saluran dalam pengaturcaraan serentak fungsi Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!