Cara menggunakan Goroutine dan Saluran di Golang

Cara menggunakan Goroutine dan Saluran di Golang

Golang ialah bahasa pengaturcaraan berprestasi tinggi yang amat sesuai untuk mengendalikan tugas serentak. Di Golang, Goroutines dan Saluran adalah dua konsep yang sangat penting yang boleh membantu kami mencapai keselarasan dan kerjasama.

Gorutin ialah unit asas tugasan serentak di Golang Ia adalah benang yang ringan. Berbanding dengan benang tradisional, Goroutines sangat murah untuk dibuat dan dimusnahkan, dan beribu-ribu Goroutines boleh dibuat dengan mudah. Dengan menggunakan Goroutines, kami boleh melaksanakan berbilang tugas pada masa yang sama dan meningkatkan prestasi program.

Berikut ialah contoh penggunaan Goroutines:

package main

import (
    "fmt"
    "time"
)

func task(id int) {
    for i := 0; i < 5; i++ {
        fmt.Printf("Goroutine %d: %d
", id, i)
        time.Sleep(time.Millisecond * 100)
    }
}

func main() {
    for i := 0; i < 3; i++ {
        go task(i)
    }

    // 保证 main 函数不会结束
    time.Sleep(time.Second * 1)
}

Dalam contoh di atas, kami mencipta tiga Goroutines untuk melaksanakan fungsi tugasan. Setiap goroutine mencetak id sendiri dan nombor yang semakin meningkat. Kami menggunakan fungsi masa.Tidur untuk menjeda setiap Goroutine untuk satu tempoh masa untuk melihat kesan pelaksanaan serentak.

Jalankan kod di atas, anda akan melihat output yang serupa dengan yang berikut:

Goroutine 0: 0
Goroutine 1: 0
Goroutine 2: 0
Goroutine 0: 1
Goroutine 1: 1
Goroutine 2: 1
...

Seperti yang dapat dilihat daripada output, ketiga-tiga Goroutines dilaksanakan pada masa yang sama, dan tiada susunan antara mereka. Ini adalah kuasa Goroutines Mereka boleh dilaksanakan serentak dalam urutan yang berbeza, dengan itu meningkatkan kecekapan pelaksanaan program.

Untuk berkomunikasi antara Goroutine, kita boleh menggunakan Saluran. Saluran ialah paip selamat jenis yang boleh digunakan untuk menghantar data dan menyegerakkan pelaksanaan Goroutines.

Berikut ialah contoh menggunakan Saluran:

package main

import "fmt"

func sum(numbers []int, result chan int) {
    sum := 0
    for _, number := range numbers {
        sum += number
    }
    result <- sum
}

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

    result := make(chan int)
    go sum(numbers[:3], result)
    go sum(numbers[3:], result)

    x, y := <-result, <-result
    total := x + y
    fmt.Println("Total:", total)
}

Dalam contoh di atas, kami menentukan fungsi jumlah yang menerima kepingan dan Saluran. Fungsi jumlah mengira jumlah nombor dalam kepingan dan menulis hasilnya ke Saluran.

Dalam fungsi utama, kami mencipta Saluran dan menggunakan dua Goroutine untuk mengira jumlah separuh pertama dan separuh kedua bahagian masing-masing. Kami menggunakan operator <- untuk membaca hasil daripada Saluran dan menambah hasil dua jumlah bersama-sama.

Jalankan kod di atas, anda akan melihat output:

Total: 15

Melalui Saluran, kita boleh mencapai perkongsian data dan komunikasi antara Goroutines. Ia memastikan penyegerakan antara Goroutines supaya Goroutines yang melaksanakan secara serentak boleh mengakses dan mengubah suai data kongsi dengan selamat.

Ringkasan: Goroutine dan Saluran di Golang adalah konsep pengaturcaraan serentak yang sangat penting. Goroutines boleh dibuat dan dimusnahkan dengan mudah dan boleh melaksanakan tugas serentak dengan cekap. Saluran boleh digunakan untuk menghantar data dan menyegerakkan antara Goroutines. Dengan menguasai penggunaan Goroutine dan Saluran, kami boleh menggunakan sepenuhnya ciri keselarasan Golang dan meningkatkan prestasi dan kebolehpercayaan program.

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