penggunaan saluran golang

Golang ialah bahasa pengaturcaraan moden yang sesuai terutamanya untuk aplikasi berasaskan pengkomputeran awan dan data besar. Bahasa mempunyai ciri kecekapan, kebolehpercayaan dan keselamatan Salah satu ciri yang paling unik ialah saluran.

Saluran ialah jenis yang sangat berkuasa dalam bahasa Golang yang membolehkan data dikongsi dengan selamat antara program serentak yang berbeza. Artikel ini akan menyelidiki penggunaan saluran dan menunjukkan cara menggunakan saluran dalam program untuk mencapai pemprosesan bersama dan penyegerakan.

Konsep Asas

Di Golang, saluran ialah objek yang digunakan untuk memindahkan data antara coroutine. Melalui saluran, Golang memastikan data selamat untuk benang apabila dibaca atau ditulis. Saluran boleh diisytiharkan dengan cara berikut:

var ch chan int           //声明一个通道变量
ch := make(chan int)      //定义通道，并初始化其容量

Terdapat tiga jenis saluran utama:

1 Saluran sehala: hanya menyokong penghantaran atau penerimaan data

2. Saluran Dua hala: menyokong penghantaran dan penerimaan data

3. Saluran dengan cache: jenis saluran dengan kapasiti tetap

Menggunakan saluran

Saluran dibuat menggunakan fungsi membuat. Mencipta saluran memerlukan penentuan jenis saluran dan kapasiti saluran (jika ia adalah saluran penimbal). Contohnya, untuk mencipta saluran penimbal dengan kapasiti 3, anda boleh menggunakan kod berikut:

ch := make(chan int, 3)

Saluran mempunyai dua operasi utama:

1 kepada yang lain melalui saluran A coroutine

2. Terima operasi: Coroutine boleh menerima data daripada saluran.

Di Golang, jenis data saluran mempunyai nilai lalai yang sama seperti pembolehubah lain. Untuk saluran, nilai ini ialah "tiada". Oleh itu, sebelum menggunakan saluran, ia mesti dimulakan menggunakan fungsi make. Jika saluran tidak dimulakan, pengecualian masa jalan "panik" dilemparkan.

Dalam pengaturcaraan sebenar, saluran boleh digunakan dalam banyak senario dan kes penggunaan yang berbeza. Berikut ialah beberapa contoh yang digunakan secara meluas:

1 Mod menyekat/tidak menyekat saluran: Di Golang, saluran boleh dijalankan dalam mod menyekat dan tidak menyekat. Dalam mod menyekat, operasi terima dan hantar saluran tunggu sehingga penghantaran atau terima selesai. Dalam mod tidak menyekat, mereka kembali serta-merta jika operasi tidak dapat diselesaikan.

Menggunakan saluran untuk menyekat komunikasi dalam Go:

package main

import "fmt"

func main() {
    ch := make(chan int)
    go func() {
        ch <- 101         //发送数据到通道
    }()
    ret := <- ch          //从通道读取数据
    fmt.Println(ret)
}

Dalam contoh ini, dua coroutine berkomunikasi dengan menghantar dan menerima data pada saluran. Setelah saluran dibuat, hantarkannya sebagai parameter kepada fungsi "go", yang mewakili fungsi yang akan dijalankan dalam goroutine.

2. Operasi segerak dan tak segerak bagi coroutine: Saluran juga boleh digunakan untuk operasi segerak dan tak segerak antara coroutine. Di Golang, menggunakan saluran untuk memindahkan data antara coroutine boleh mencapai operasi segerak dan tak segerak bagi coroutine.

Kod sampel untuk operasi segerak adalah seperti berikut:

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan string)
    go func() {
        time.Sleep(time.Second * 2)
        ch <- "golang"
    }()
    fmt.Println("Waiting for the channel...")
    data := <- ch
    fmt.Println("Got data:", data)
}

Dalam contoh ini, sekeping data akan dihantar dari coroutine ke saluran selepas 2 saat. Proses utama akan menunggu saluran untuk menyelesaikan operasi hantar atau terima sebelum melaksanakan kod berikutnya.

Kod sampel untuk operasi tak segerak adalah seperti berikut:

package main 

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan int, 1)
    go func() {
        for i := 0; i < 5; i++ {
            ch <- i
            fmt.Printf("goroutine #%d puts %d at %v
",i,i, time.Now().Unix())
        }
    }()
    time.Sleep(time.Second * 2)
    for i := 0; i < 5; i++ {
        v := <- ch
        fmt.Printf("main thread gets %d at %v
",v, time.Now().Unix())
    }
}

Kod ini akan menjana saluran cache dan menghantarnya sebagai parameter kepada fungsi merentas coroutine. Fungsi ini menulis integer ke saluran, dari 0 hingga 4.

Dalam proses utama, kod menunggu selama 2 saat untuk bertukar, dan kemudian membaca data daripada saluran dalam gelung. Output menunjukkan bahawa data dalam saluran yang diakses oleh utas utama dan cap waktu pelaksanaan rentas coroutine berada dalam susunan terbalik.

3 Mod lelaran saluran: Saluran boleh diulang untuk mengakses semua nilai saluran.

package main

import "fmt"

func main() {
    ch := make(chan int,4)
    ch <- 34
    ch <- 18
    ch <- 89
    ch <- 56
    close(ch)
    for x := range ch {
        fmt.Println(x)
    }
}

Dalam mod lelaran, rentas nilai dalam saluran mengikut julat dan keluar secara automatik apabila saluran ditutup.

Ringkasan

Artikel ini memperkenalkan penggunaan asas saluran Golang dan menunjukkan cara menggunakan saluran untuk mencapai operasi kolaboratif, segerak dan tak segerak antara coroutine. Melalui pemahaman dan kebiasaan dengan saluran, program serentak yang cekap, selamat dan boleh dipercayai dapat dilaksanakan dengan lebih baik.

Atas ialah kandungan terperinci penggunaan saluran golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!