Mod konkurensi dalam Golang: Saluran dan Talian Paip

Mod Concurrency di Golang: Saluran dan Talian Paip

Di Golang, kita boleh menggunakan goroutine untuk melaksanakan pengaturcaraan serentak. Dalam pembangunan sebenar, kita sering perlu mengendalikan aliran data tugas serentak. Golang menyediakan dua mod konkurensi, saluran dan saluran paip, untuk menangani situasi ini.

Saluran ialah primitif serentak yang sangat berkuasa di Golang, digunakan untuk menghantar data antara goroutin. Ia memastikan penyegerakan dan penghantaran data yang selamat. Dengan menghantar dan menerima data pada saluran, kami memastikan susunan dan penyegerakan antara goroutine.

Pipelines ialah corak konkurensi yang memproses aliran data dengan menyambungkan berbilang goroutin. Setiap goroutine mempunyai saluran input dan output, dan dengan merantainya bersama-sama, data boleh mengalir dan diproses antara semua goroutine.

Pertama, mari kita lihat penggunaan asas saluran. Dalam Golang, anda boleh menggunakan fungsi make() untuk mencipta saluran.

ch := make(chan int)

Kami boleh menggunakan operator <- untuk menghantar data ke saluran, contohnya: <- 操作符将数据发送到 channel 中，例如：

ch <- 10

并且使用 <- 操作符从 channel 中接收数据，例如：

x := <-ch

请注意，接收操作将被阻塞，直到有数据可用。而发送操作也会被阻塞，直到有其他 goroutine 准备好接收数据。

下面是一个简单的示例，使用一个 channel 将生成的随机数发送到另一个 goroutine 中：

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    ch := make(chan int)

    go randomGenerator(ch) // 启动生成随机数的 goroutine

    // 等待接收随机数并打印
    for i := 0; i < 10; i++ {
        num := <-ch
        fmt.Println("Received random number:", num)
        time.Sleep(1 * time.Second)
    }
}

func randomGenerator(ch chan int) {
    for {
        // 生成随机数并发送到 channel
        num := rand.Intn(100)
        ch <- num
    }
}

在上面的示例中，我们通过 randomGenerator() 函数生成随机数，并将其发送到 ch channel 中。main 函数则从 channel 中接收随机数并打印。

接下来，让我们来介绍一下 pipelines 的并发模式。一个 pipeline 包含多个 goroutine，通过将它们串联在一起，可以构建一个处理数据流的网络。

假设我们有一个数字列表，我们想对列表中的每个数字进行平方操作，然后将结果打印出来。我们可以使用两个 goroutine 来实现这个功能：一个用于计算平方，另一个用于打印结果。

package main

import (
    "fmt"
)

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    input := make(chan int)
    output := make(chan int)

    // 启动计算平方的 goroutine
    go square(input, output)

    // 启动打印结果的 goroutine
    go printer(output)

    // 将数字发送到 input channel
    for _, num := range numbers {
        input <- num
    }

    // 关闭 input channel，表示数据发送完毕
    close(input)

    // 等待所有结果被打印
    <-output
}

func square(input chan int, output chan int) {
    for num := range input {
        // 计算平方，并发送结果到 output channel
        result := num * num
        output <- result
    }

    // 关闭 output channel，表示计算完毕
    close(output)
}

func printer(output chan int) {
    for result := range output {
        // 打印结果
        fmt.Println("Result:", result)
    }

    // 发送信号表示输出完毕
    output <- 0
}

在上面的示例中，我们首先创建一个 input channel 和一个 output channel。然后我们启动了两个 goroutine：square() 用于计算平方操作，并将结果发送到 output channel，printer() 则从 output channel 中接收结果并打印。

在 main 函数中，我们使用 for 循环将数字发送到 input channel 中。然后我们关闭 input channel，表示数据发送完毕。最后我们等待从 outputrrreee

dan menggunakan operator <- untuk menerima data daripada saluran, Contohnya:

rrreee

Sila ambil perhatian bahawa operasi terima akan disekat sehingga data tersedia. Operasi penghantaran juga akan disekat sehingga goroutine lain bersedia untuk menerima data. 🎜🎜Berikut ialah contoh mudah yang menggunakan saluran untuk menghantar nombor rawak yang dijana ke goroutine lain: 🎜rrreee🎜Dalam contoh di atas, kami menjana nombor rawak melalui fungsi randomGenerator(), dan menghantar ia ke saluran ch. Fungsi utama menerima nombor rawak daripada saluran dan mencetaknya. 🎜🎜Seterusnya, mari kita perkenalkan mod concurrency saluran paip. Saluran paip mengandungi berbilang goroutin, dan dengan melatakannya bersama-sama, rangkaian boleh dibina untuk memproses aliran data. 🎜🎜 Katakan kita mempunyai senarai nombor dan kita mahu kuasa duakan setiap nombor dalam senarai dan kemudian mencetak hasilnya. Kita boleh menggunakan dua goroutine untuk melaksanakan fungsi ini: satu untuk mengira segi empat sama dan satu lagi untuk mencetak hasilnya. 🎜rrreee🎜Dalam contoh di atas, kami mula-mula mencipta saluran input dan saluran output. Kemudian kami memulakan dua goroutine: square() digunakan untuk mengira operasi segi empat sama dan menghantar hasilnya ke saluran output, printer() kemudian Terima hasil daripada saluran output dan cetaknya. 🎜🎜Dalam fungsi utama, kami menggunakan gelung for untuk menghantar nombor ke saluran input. Kemudian kami menutup saluran input, menunjukkan bahawa data dihantar. Akhirnya kami menunggu untuk menerima isyarat daripada saluran output yang menunjukkan bahawa semua keputusan telah dicetak. 🎜🎜Dengan menggunakan saluran dan saluran paip, kami boleh melaksanakan pemprosesan serentak aliran data dengan mudah. Mereka menyediakan Golang dengan cara pengaturcaraan serentak yang berkuasa dan ringkas, membolehkan kami mengendalikan tugas serentak dengan cekap. Sama ada pemindahan data ringkas atau rangkaian pemprosesan data yang kompleks, kedua-dua mod konkurensi ini boleh membantu kami menulis program serentak yang cekap dan boleh dipercayai. 🎜

Atas ialah kandungan terperinci Mod konkurensi dalam Golang: Saluran dan Talian Paip. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!