Penggunaan lanjutan Goroutine dan Saluran di Golang

Penggunaan lanjutan Goroutine dan Saluran di Golang

Dalam pengaturcaraan serentak Golang, Goroutines dan Saluran ialah dua konsep yang sangat penting. Goroutines ialah utas ringan yang boleh dilaksanakan secara serentak, manakala Saluran ialah mekanisme komunikasi antara Goroutines. Dalam artikel ini, kami akan meneroka penggunaan lanjutan Goroutine dan Saluran di Golang dan menggambarkannya dengan contoh kod.

1. Penggunaan lanjutan Goroutines

1. Pemultipleksan Goroutines boleh dicapai melalui penyataan pilih. Dalam contoh kod di bawah, kami mencipta dua Goroutine untuk mengira jujukan Fibonacci dan faktorial masing-masing. Melalui penyataan pilih, kita boleh menunggu dua Goroutine selesai pada masa yang sama dan mencetak hasil pengiraan.

package main

import (
    "fmt"
)

func fibonacci(n int, c chan<- int) {
    x, y := 0, 1
    for i := 0; i < n; i++ {
        c <- x
        x, y = y, x+y
    }
    close(c)
}

func factorial(n int, c chan<- int) {
    result := 1
    for i := 1; i <= n; i++ {
        result *= i
    }
    c <- result
    close(c)
}

func main() {
    fibChan := make(chan int)
    factChan := make(chan int)

    go fibonacci(10, fibChan)
    go factorial(5, factChan)

    for {
        select {
        case fib, ok := <-fibChan:
            if ok {
                fmt.Println("Fibonacci:", fib)
            } else {
                fibChan = nil
            }

        case fact, ok := <-factChan:
            if ok {
                fmt.Println("Factorial:", fact)
            } else {
                factChan = nil
            }

        default:
            if fibChan == nil && factChan == nil {
                return
            }
        }
    }
}

2. Anda boleh menunggu penyiapan Goroutines melalui WaitGroup. WaitGroup ialah kaunter yang boleh digunakan untuk menunggu selesainya kumpulan Goroutines. Dalam contoh kod di bawah, kami mencipta dua Goroutine untuk mengira jujukan Fibonacci dan faktorial masing-masing. Dengan sync.WaitGroup, kita boleh menunggu dua Goroutine selesai serentak.

package main

import (
    "fmt"
    "sync"
)

func fibonacci(n int, c chan<- int, wg *sync.WaitGroup) {
    defer wg.Done()
    x, y := 0, 1
    for i := 0; i < n; i++ {
        c <- x
        x, y = y, x+y
    }
    close(c)
}

func factorial(n int, c chan<- int, wg *sync.WaitGroup) {
    defer wg.Done()
    result := 1
    for i := 1; i <= n; i++ {
        result *= i
    }
    c <- result
    close(c)
}

func main() {
    fibChan := make(chan int)
    factChan := make(chan int)
    var wg sync.WaitGroup

    wg.Add(2)

    go fibonacci(10, fibChan, &wg)
    go factorial(5, factChan, &wg)

    go func() {
        wg.Wait()
        close(fibChan)
        close(factChan)
    }()

    for {
        select {
        case fib, ok := <-fibChan:
            if ok {
                fmt.Println("Fibonacci:", fib)
            } else {
                fibChan = nil
            }

        case fact, ok := <-factChan:
            if ok {
                fmt.Println("Factorial:", fact)
            } else {
                factChan = nil
            }

        default:
            if fibChan == nil && factChan == nil {
                return
            }
        }
    }
}

2. Penggunaan lanjutan Saluran

1. Anda boleh mengawal kelakuan menyekat Saluran dengan menetapkan saiz penimbal. Secara lalai, Saluran tidak ditimbal, iaitu penghantaran dan penerimaan akan disekat sehingga pihak lain bersedia. Kita boleh menetapkan saiz penimbal melalui parameter kedua fungsi make. Dalam contoh kod berikut, kami mencipta Saluran dengan saiz penimbal 3 dan menghantar 3 nilai kepadanya. Oleh kerana penimbal tidak penuh, hantaran tidak disekat.

package main

import (
    "fmt"
)

func main() {
    ch := make(chan int, 3)
    ch <- 1
    ch <- 2
    ch <- 3

    fmt.Println(<-ch)
    fmt.Println(<-ch)
    fmt.Println(<-ch)
}

2. Anda boleh mengulangi Saluran melalui kata kunci julat. Kata kunci julat boleh digunakan untuk mengulang nilai dalam Saluran Apabila Saluran ditutup, lelaran akan tamat secara automatik. Dalam contoh kod berikut, kami membuat pembilang Goroutines dan menghantar 5 nilai ke Saluran yang tidak dibuffer. Dalam fungsi utama, kami menggunakan kata kunci julat untuk mengulang nilai dalam Saluran dan mencetaknya. Apabila Saluran ditutup, gelung julat akan tamat secara automatik.

package main

import (
    "fmt"
    "time"
)

func counter(ch chan<- int) {
    for i := 1; i <= 5; i++ {
        ch <- i
        time.Sleep(time.Second)
    }
    close(ch)
}

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

    for val := range ch {
        fmt.Println(val)
    }
}

Ringkasnya, Goroutine dan Saluran di Golang menyediakan keupayaan pengaturcaraan serentak yang berkuasa dan fleksibel. Kami mempunyai lebih kawalan ke atas gelagat Goroutine dan Saluran melalui penggunaan lanjutan seperti penyataan pilih, WaitGroup, penimbal dan kata kunci julat. Kami berharap contoh kod yang diberikan dalam artikel ini dapat membantu pembaca memahami dan menggunakan penggunaan lanjutan ini dengan lebih baik.

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