Goroutine dan Saluran di Golang melaksanakan komunikasi serentak

Gorutin dan Saluran di Golang melaksanakan komunikasi serentak

Pengenalan:
Dalam pembangunan perisian, melaksanakan komunikasi serentak adalah topik penting. Golang ialah bahasa yang menyokong pengaturcaraan serentak, dan ia menyediakan mekanisme Goroutine dan Saluran yang berkuasa untuk mencapai komunikasi serentak. Artikel ini akan memperkenalkan konsep Goroutine dan Saluran, dan menggunakan contoh kod untuk menunjukkan cara mereka melaksanakan komunikasi serentak.

1. Goroutines
Goroutine di Golang ialah benang ringan yang dicipta oleh kata kunci Go. Ciri utama Goroutines ialah penciptaan dan pemusnahannya sangat pantas, dan pelaksanaannya tidak menyekat, iaitu, satu Goroutine tidak akan menyekat pelaksanaan Goroutine yang lain apabila melaksanakan.

Berikut ialah contoh mudah yang menunjukkan cara mencipta Goroutine:

package main

import (
    "fmt"
    "time"
)

func count() {
    for i := 1; i <= 5; i++ {
        fmt.Println(i)
        time.Sleep(time.Millisecond * 500)
    }
}

func main() {
    go count()
    time.Sleep(time.Second * 3)
    fmt.Println("done")
}

Dalam kod di atas, fungsi kiraan ialah Goroutine. Dalam fungsi utama, kami menggunakan kata kunci go untuk memulakan pelaksanaan fungsi kiraan tanpa menyekat pelaksanaan fungsi utama. Dengan memanggil fungsi masa.Sleep, kami menjeda pelaksanaan fungsi utama secara ringkas supaya fungsi kiraan mempunyai masa yang mencukupi untuk dilaksanakan.

2. Saluran
Saluran di Golang ialah saluran paip untuk komunikasi antara Goroutines. Melalui Saluran, Goroutine boleh menghantar data kepada atau menerima data daripada Goroutine lain. Saluran menyediakan ciri penyegerakan dan penyekatan untuk memastikan pertukaran data yang selamat.

Berikut ialah contoh mudah yang menunjukkan cara menggunakan Saluran untuk komunikasi serentak:

package main

import (
    "fmt"
)

func sendData(data chan<- int) {
    for i := 0; i < 5; i++ {
        data <- i
    }
    close(data)
}

func receiveData(data <-chan int, done chan<- bool) {
    for num := range data {
        fmt.Println(num)
    }
    done <- true
}

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

    go sendData(data)
    go receiveData(data, done)

    <-done
}

Dalam kod di atas, kami mentakrifkan dua fungsi: sendData dan receiveData. Fungsi sendData digunakan untuk menghantar data ke Saluran, dan fungsi receiveData digunakan untuk menerima data daripada Saluran. Dalam fungsi utama, kami menggunakan kata kunci go untuk memulakan pelaksanaan kedua-dua fungsi ini masing-masing, supaya ia dilaksanakan serentak.

Selain itu, dalam fungsi utama, kami menentukan saluran selesai (Saluran) untuk memberitahu utas utama untuk keluar selepas semua penerimaan data selesai. Pada penghujung fungsi utama, kami menggunakan pernyataan <-done untuk menunggu mesej daripada saluran selesai (Saluran).

Melalui Goroutine dan Saluran, kami boleh mencapai pelaksanaan tak segerak dan komunikasi selamat dalam pengaturcaraan serentak.

Kesimpulan:
Artikel ini memperkenalkan Goroutine dan Saluran di Golang dan cara menggunakannya untuk mencapai komunikasi serentak. Goroutine ialah benang ringan yang dicipta dan dimusnahkan dengan sangat cepat dan tidak menyekat pelaksanaan Goroutine lain semasa pelaksanaan. Saluran ialah mekanisme komunikasi yang digunakan antara Goroutines Data dihantar dan diterima melalui Saluran untuk memastikan keselamatan data untuk operasi serentak. Saya harap artikel ini membantu anda memahami pengaturcaraan serentak di Golang.

Rujukan:

• Spesifikasi Bahasa Pengaturcaraan The Go: https://golang.org/ref/spec
• A Tour of Go: https://tour.golang.org/concurrency/1

Atas ialah kandungan terperinci Goroutine dan Saluran di Golang melaksanakan komunikasi serentak. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!