開源技術教學文件網 撰寫共時性 (Concurrency) 程式

最後修改日期為 JUN 25, 2019

前言

由於 CPU 的時脈已經到物理上限,現在的硬體都往多核心、多 CPU 發展。同樣地,單一的大型伺服器相當昂貴,而且擴充量有限,使用多台主機組成的叢集 (cluster) 則相對易於擴充。然而,若程式碼沒有使用共時性 (concurrency) 的特性來撰寫,則無法真正發揮平行處理 (parallel computing) 所帶來的效能提升。

Go 主要的特色之一,就在於其對共時性程式的支援;大部分程式語言以函式庫來支援共時性程式,但 Go 將其內建在語法中。Go 的並時性程式有兩種,一種是以 CSP (communicating sequential processes) 模型的並時性程式,一種是傳統的多執行緒 (multi-thread) 程式。由於 Go 將 CSP 模型內建在語法中,通常建議使用這些內建功能來寫共時性程式。

goroutine 是輕量級執行緒 (lightweight thread)

大部分的程式語言,像是 C++ 或 Java 等,以執行緒 (thread) 做為並行程式的單位。Go 程式以 goroutine 做為並行執行的程式碼區塊,goroutine 類似於執行緒,但更輕量,一次啟動數百甚至數千個以上的 goroutine 也不會占用太多記憶體。要使用 goroutine,在函式前加上 go 關鍵字即可。以下為使用 goroutine 的實例:

package main
 
import (
    "log"
    "os"
    "sync"
)
 
func main() {
    // A goroutine-safe console printer.
    logger := log.New(os.Stdout, "", 0)
 
    // Sync between goroutines.
    var wg sync.WaitGroup
 
    // Add goroutine 1.
    wg.Add(1)
    go func() {
        defer wg.Done()
        logger.Println("Print from goroutine 1")
    }()
 
    // Add goroutine 2.
    wg.Add(1)
    go func() {
        defer wg.Done()
        logger.Println("Print from goroutine 2")
    }()
 
    // Add goroutine 3.
    wg.Add(1)
    go func() {
        defer wg.Done()
        logger.Println("Print from goroutine 3")
    }()
 
    logger.Println("Print from main")
 
    // Wait all goroutines.
    wg.Wait()
}

在本例中,我們建立了三個 goroutine。由於 goroutine 和主程式並時執行,若我們沒有使用 WaitGroup 將程式同步化,本程式在主程式結束時即提早結束,因此,我們宣告 wg 變數,在程式尾端等待所有 goroutine 執行結束。

如果讀者多執行幾次本程式,會發現每次印出字串的順序不同。並時性程式和傳統的循序式程式的思維不太一樣,執行並時性程式時無法保證程式運行的先後順序,需注意。

利用 channel 在 goroutine 間傳遞資料

上述的 goroutine 內的資料是各自獨立的,而 Go 用 channel 在不同並行程式間傳遞資料。如下例:

package main
 
import "fmt"
 
func main() {
    // Create a channel
    message := make(chan string)
 
    // Init a goroutine.
    go func() {
        // Send some data into the channel.
        message <- "Hello from channel"
    }()
 
    // Receive the data from the channel.
    msg := <-message
    fmt.Println(msg)
}

由於通道在傳輸時,會阻塞 (blocking) 程式的行進,在此處,我們不需要另外設置 WaitGroup。

設置固定大小的 buffered channel

前述的 channel 是無緩衝的。我們也可以設置有緩衝的 (buffered) channel,buffered channel 有固定的大小,這樣就不需等待其他的 goroutine,可以直接傳送資料。

package main
 
import (
    "log"
    "os"
    "sync"
)
 
func main() {
    // A goroutine-safe console printer.
    logger := log.New(os.Stdout, "", 0)
 
    // Sync among all goroutines.
    var wg sync.WaitGroup
 
    // Make a buffered channel.
    ch := make(chan int, 10)
 
    for i := 1; i <= 10; i++ {
        ch <- i
        wg.Add(1)
        go func() {
            defer wg.Done()
            logger.Println("Print from goroutine ", <-ch)
        }()
    }
 
    logger.Println("Print from main")
    wg.Wait()
}

指定 channel 的方向

我們在設置 channel 時,可指定其方向,如下例:

package main
 
import "fmt"
 
func ping(pings chan<- string, msg string) {
    pings <- msg
}
 
func pong(pings <-chan string, pongs chan<- string) {
    msg := <-pings
    pongs <- msg
}
 
func main() {
    pings := make(chan string, 1)
    pongs := make(chan string, 1)
    ping(pings, "passed message")
    pong(pings, pongs)
    fmt.Println(<-pongs)
}

關閉 channel

若不用 channel 時,可用 close 函式將 channel 關閉,如下例:

package main
 
import "fmt"
 
func main() {
    ch := make(chan int, 4)
    ch <- 2
    ch <- 4
    close(ch)
    // ch <- 6 // panic, send on closed channel
 
    fmt.Println(<-ch)
    fmt.Println(<-ch)
    fmt.Println(<-ch) // closed, returns zero value for element
}

使用 select 敘述在多個 channel 間做選擇

透過 select,我們可以在多個 channel 中做選擇。如下例:

package main
 
import "time"
import "fmt"
 
func main() {
    // For our example we'll select across two channels.
    c1 := make(chan string)
    c2 := make(chan string)
 
    // Each channel will receive a value after some amount
    // of time, to simulate e.g. blocking RPC operations
    // executing in concurrent goroutines.
    go func() {
        time.Sleep(time.Second * 1)
        c1 <- "one"
    }()
    go func() {
        time.Sleep(time.Second * 1)
        c2 <- "two"
    }()
 
    // We'll use `select` to await both of these values
    // simultaneously, printing each one as it arrives.
    for i := 0; i < 2; i++ {
        select {
        case msg1 := <-c1:
            fmt.Println("received", msg1)
        case msg2 := <-c2:
            fmt.Println("received", msg2)
        }
    }
}

利用 channel 撰寫 generator

利用 channel 可以撰寫共時執行的 generator,如下例:

package main
 
import (
    "fmt"
    "strings"
)
 
func main() {
    data := []string{
        "The yellow fish swims slowly in the water",
        "The brown dog barks loudly after a drink from its water bowl",
        "The dark bird of prey lands on a small tree after hunting for fish",
    }
 
    histogram := make(map[string]int)
    wordsCh := make(chan string)
 
    go func() {
        defer close(wordsCh)
 
        for _, line := range data {
            words := strings.Split(line, " ")
 
            for _, word := range words {
                word = strings.ToLower(word)
                wordsCh <- word
            }
        }
    }()
 
    for {
        word, opened := <- wordsCh
        if !opened {
            break
        }
        histogram[word]++
    }
 
    for k, v := range histogram {
        fmt.Println(fmt.Sprintf("%s\t(%d)", k, v))
    }
}

利用 mutex 將共時性程式同步化

除了前述的 goroutine 和 channel 外,Go 也提供較傳統的 Mutex。在共時性程式中,mutex 會將某一段程式暫時鎖住,避免兩個共時程式競爭同一塊資料。以下範例節錄自一個假想的向量類別:

package vector
 
import (
    "sync"
)
 
type IVector interface {
    Len() int
    GetAt(int) float64
    SetAt(int, float64)
}
 
type Vector struct {
    sync.RWMutex
    vec []float64
}
 
func New(args ...float64) IVector {
    v := new(Vector)
    v.vec = make([]float64, len(args))
 
    for i, e := range args {
        v.SetAt(i, e)
 
    }
 
    return v
}
 
// The length of the vector
func (v *Vector) Len() int {
    return len(v.vec)
}
 
// Getter
func (v *Vector) GetAt(i int) float64 {
    if i < 0 || i >= v.Len() {
        panic("Index out of range")
    }
 
    return v.vec[i]
}
 
// Setter
func (v *Vector) SetAt(i int, data float64) {
    if i < 0 || i >= v.Len() {
        panic("Index out of range")
    }
 
    v.Lock()
    v.vec[i] = data
    v.Unlock()
}
 
/ Vector algebra delegating to function object.
// This method delegates vector algebra to function object set by users, making
// it faster then these methods relying on reflection.
func Apply(v1 IVector, v2 IVector, f func(float64, float64) float64) IVector {
    _len := v1.Len()
 
    if !(_len == v2.Len()) {
        panic("Unequal vector size")
    }
 
    out := WithSize(_len)
 
    var wg sync.WaitGroup
 
    for i := 0; i < _len; i++ {
        wg.Add(1)
 
        go func(v1 IVector, v2 IVector, out IVector, f func(float64, float64) float64, i int) {
            defer wg.Done()
 
            out.SetAt(i, f(v1.GetAt(i), v2.GetAt(i)))
        }(v1, v2, out, f, i)
    }
 
    wg.Wait()
 
    return out
}

當我們要將資料存入內部的 float64 切片時,透過 Mutex 將切片暫時鎖住,避免多個程式同時存取切片。在此情形外,資料都是各自獨立的,所以,可以開啟多個 goroutine 進行並行運算。

分享本文
Facebook Twitter LinkedIn LINE Skype EverNote GMail Yahoo Yahoo
追蹤本站
Facebook Facebook Twitter