Pengalaman permohonan Goroutines dan Saluran di Golang

Pengalaman aplikasi Goroutines dan Saluran di Golang

Golang ialah bahasa pengaturcaraan merentas platform dengan prestasi cekap dan sintaks yang ringkas dan Goroutines dan Saluran ialah dua ciri penting pengaturcaraan serentaknya. Artikel ini akan berkongsi beberapa pengalaman menggunakan Goroutine dan Saluran dalam aplikasi praktikal dan menunjukkannya melalui contoh kod.

Pertama sekali, Goroutines ialah benang ringan di Golang yang boleh berjalan dalam cara tak segerak. Dengan menambahkan kata kunci "go" sebelum panggilan fungsi, blok kod fungsi boleh dibungkus ke dalam Goroutine. Berikut ialah contoh mudah:

package main

import (
    "fmt"
    "time"
)

func printNumbers() {
    for i := 1; i <= 5; i++ {
        fmt.Println(i)
    }
}

func main() {
    go printNumbers() // 启动一个 Goroutine

    time.Sleep(1 * time.Second) // 等待 Goroutine 执行完毕
}

Dalam kod di atas, kami menggunakan go printNumbers() dalam fungsi main untuk memulakan Goroutine dan menggunakan time berfungsi untuk menunggu pelaksanaan Goroutine selesai. Dengan cara ini, semasa Goroutine sedang melaksanakan, utas utama boleh terus melaksanakan tugas lain. main 函数中使用 go printNumbers() 启动了一个 Goroutine，并使用 time.Sleep 函数来等待 Goroutine 的执行完毕。这样就可以在 Goroutine 执行的同时，主线程也可以继续执行其他任务。

接下来，Channels 是 Golang 中用于 Goroutines 之间通信的机制。可以将 Channel 看作是一条管道，Goroutine 可以将数据发送到 Channel 中，而其他 Goroutine 则可以从 Channel 中接收数据。下面是一个简单的示例：

package main

import (
    "fmt"
)

func printNumbers(numbers chan int) {
    for i := 1; i <= 5; i++ {
        numbers <- i // 发送数据到 Channel
    }
    close(numbers) // 关闭 Channel
}

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

    go printNumbers(numbers)

    for number := range numbers { // 从 Channel 中接收数据
        fmt.Println(number)
    }
}

上述代码中，我们创建了一个整型的 Channel numbers，并在 printNumbers 函数中使用 <- 操作符发送数据到该 Channel 中。在 main 函数中使用 range 循环从 Channel 中接收数据，这里需要注意的是，当 Channel 被关闭后，循环会自动退出。

除了在 Goroutines 之间传递数据，Channels 还可以用于控制 Goroutines 的执行顺序。下面是一个使用两个 Channels 实现的简单示例：

package main

import (
    "fmt"
)

func printNumbers(numbers chan int, done chan bool) {
    for i := 1; i <= 5; i++ {
        numbers <- i // 发送数据到 Channel
    }
    done <- true // 发送完成信号到 done Channel
}

func printSquares(numbers chan int, done chan bool) {
    for number := range numbers { // 从 numbers Channel 中接收数据
        fmt.Println(number * number)
    }
    done <- true // 发送完成信号到 done Channel
}

func main() {
    numbers := make(chan int)
    done := make(chan bool)

    go printNumbers(numbers, done)
    go printSquares(numbers, done)

    <-done // 等待 printNumbers Goroutine 完成
    <-done // 等待 printSquares Goroutine 完成
}

上述代码中，我们创建了两个 Channels numbers 和 done，分别用于传递数字和完成信号。在 printNumbers 和 printSquares 两个函数中，我们通过 Channel 的方式实现了数据的交换和控制 Goroutines 的执行顺序。最后通过 <-done

Seterusnya, Saluran adalah mekanisme di Golang untuk komunikasi antara Goroutines. Saluran boleh dianggap sebagai paip Goroutine boleh menghantar data ke Saluran, dan Goroutine lain boleh menerima data daripada Saluran. Berikut ialah contoh mudah:

rrreee

Dalam kod di atas, kami mencipta Saluran integer nombor dan menggunakan <- dalam fungsi printNumbers operator menghantar data ke Saluran. Gunakan gelung julat dalam fungsi utama untuk menerima data daripada Saluran Perlu diingat bahawa apabila Saluran ditutup, gelung akan keluar secara automatik.

Selain menghantar data antara Goroutines, Saluran juga boleh digunakan untuk mengawal perintah pelaksanaan Goroutines. Berikut ialah contoh mudah yang dilaksanakan menggunakan dua Saluran:

rrreee
1. Dalam kod di atas, kami mencipta dua Saluran nombor dan selesai, yang digunakan untuk menghantar nombor dan penyelesaian masing-masing Isyarat. Dalam dua fungsi printNumbers dan printSquares, kami melaksanakan pertukaran data dan mengawal susunan pelaksanaan Goroutines melalui Saluran. Akhir sekali, gunakan <-done untuk menyekat utas utama dan tunggu dua Goroutines menyelesaikan pelaksanaan.
2. Melalui contoh kod di atas, kita dapat melihat fungsi hebat Goroutines dan Saluran untuk mencapai pengaturcaraan serentak yang cekap di Golang. Sudah tentu, aplikasi Goroutine dan Saluran tidak terhad kepada contoh di atas Bergantung pada keperluan dan senario sebenar, kami boleh menggunakan kedua-dua ciri ini secara fleksibel untuk meningkatkan prestasi program dan keupayaan serentak.
3. Dalam aplikasi praktikal, kita perlu memberi perhatian kepada perkara-perkara berikut:

Apabila menggunakan Goroutines, beri perhatian untuk mengawal bilangan concurrency untuk mengelakkan Goroutines yang berlebihan menyebabkan kehabisan sumber sistem.

🎜Apabila menggunakan Saluran untuk pemindahan data, gunakan saiz penimbal yang sesuai untuk mengimbangi kelajuan penghantaran dan penerimaan bagi mengelakkan kebuntuan atau penyekatan yang serius. 🎜🎜Selepas Saluran ditutup, elakkan terus menghantar data kepadanya, jika tidak, ia akan menyebabkan panik. 🎜🎜🎜Ringkasnya, Goroutines dan Saluran ialah ciri pengaturcaraan serentak yang berkuasa di Golang Penggunaan yang betul boleh meningkatkan prestasi dan keupayaan serentak program. Melalui demonstrasi kod sampel, kami mempunyai pemahaman yang lebih jelas tentang penggunaan Goroutines dan Saluran. Dalam aplikasi sebenar, kita harus memilih dan menggunakan kedua-dua ciri ini secara fleksibel untuk mencapai pengaturcaraan serentak yang cekap berdasarkan keperluan dan senario. 🎜

Atas ialah kandungan terperinci Pengalaman permohonan Goroutines dan Saluran di Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!