Golang 中 Goroutines 和 Channels 的高階用法

Golang 中 Goroutines 和 Channels 的高階用法

在 Golang 的並發程式設計中，Goroutines 和 Channels 是兩個非常重要的概念。 Goroutines 是輕量級線程，可以並發執行，而 Channels 則是 Goroutines 之間通訊的機制。在這篇文章中，我們將探討 Golang 中 Goroutines 和 Channels 的進階用法，並透過程式碼範例來說明。

一、Goroutines 的高階用法

1. 可以透過 select 語句來實作 Goroutines 的多重化。在下面的程式碼範例中，我們建立了兩個 Goroutines，分別用於計算斐波那契數列和階乘。透過 select 語句，我們可以等待兩個 Goroutines 同時完成，並將計算結果列印出來。

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. 可以透過 WaitGroup 來等待 Goroutines 的完成。 WaitGroup 是一個計數器，可以用來等待一組 Goroutines 的結束。在下面的程式碼範例中，我們建立了兩個 Goroutines，分別用於計算斐波那契數列和階乘。透過 sync.WaitGroup，我們可以等待兩個 Goroutines 同時完成。

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
            }
        }
    }
}

二、Channels 的進階用法

1. 可以透過設定緩衝區大小來控制 Channel 的阻塞行為。預設情況下，Channel 是無緩衝的，即發送和接收都會阻塞直到對方準備好。我們可以透過 make 函數的第二個參數來設定緩衝區大小。在下面的程式碼範例中，我們建立了一個擁有緩衝區大小為 3 的 Channel，並向其中發送了 3 個值。由於緩衝區未滿，發送不會阻塞。

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. 可以透過 range 關鍵字來迭代 Channel。 range 關鍵字可用於迭代 Channel 中的值，當 Channel 關閉時，迭代會自動結束。在下面的程式碼範例中，我們建立了一個計數器 Goroutines，並在一個無緩衝的 Channel 中發送了 5 個值。在 main 函數中，我們透過 range 關鍵字來迭代 Channel 中的值，並將其列印出來。當 Channel 關閉後，range 循環會自動結束。

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)
    }
}

綜上所述，Golang 中的 Goroutines 和 Channels 提供了強大且靈活的並發程式設計能力。透過選擇語句、WaitGroup、緩衝區和 range 關鍵字等進階用法，我們可以更好地控制 Goroutines 和 Channels 的行為。希望本文所給的程式碼範例能幫助讀者更好地理解和應用這些進階用法。

以上是Golang 中 Goroutines 和 Channels 的高階用法的詳細內容。更多資訊請關注PHP中文網其他相關文章！