golang 最吸引人的地方可能就是并發(fā)了，無論代碼的編寫上，還是性能上面，golang 都有絕對的優(yōu)勢
學(xué)習(xí)一個語言的并發(fā)特性，我喜歡實現(xiàn)一個生產(chǎn)者消費者模型，這個模型非常經(jīng)典，適用于很多的并發(fā)場景，下面我通過這個模型，來簡單介紹一下 golang 的并發(fā)編程
go 并發(fā)語法
協(xié)程 go
協(xié)程是 golang 并發(fā)的最小單元，類似于其他語言的線程，只不過線程的實現(xiàn)借助了操作系統(tǒng)的實現(xiàn)，每次線程的調(diào)度都是一次系統(tǒng)調(diào)用，需要從用戶態(tài)切換到內(nèi)核態(tài)，這是一項非常耗時的操作，因此一般的程序里面線程太多會導(dǎo)致大量的性能耗費在線程切換上。而在 golang 內(nèi)部實現(xiàn)了這種調(diào)度，協(xié)程在這種調(diào)度下面的切換非常的輕量級，成百上千的協(xié)程跑在一個 golang 程序里面是很正常的事情
golang 為并發(fā)而生，啟動一個協(xié)程的語法非常簡單，使用 go 關(guān)鍵字即可
go func () {
// do something
}
同步信號 sync.WaitGroup
多個協(xié)程之間可以通過 sync.WaitGroup 同步，這個類似于 Linux 里面的信號量
var wg sync.WaitGroup // 申明一個信號量
wg.Add(1) // 信號量加一
wg.Done() // 信號量減一
wg.Wait() // 信號量為正時阻塞，直到信號量為0時被喚醒
通道 chan
通道可以理解為一個消息隊列，生產(chǎn)者往隊列里面放，消費者從隊列里面取。通道可以使用 close 關(guān)閉
ic := make(chan int, 10) // 申明一個通道
ic - 10 // 往通道里面放
i := - ic // 從通道里面取
close(ic) // 關(guān)閉通道
生產(chǎn)者消費者實現(xiàn)
定義產(chǎn)品類
這個產(chǎn)品類根據(jù)具體的業(yè)務(wù)需求定義
type Product struct {
name int
value int
}
生產(chǎn)者
如果 stop 標(biāo)志不為 false，不斷地往通道里面放 product，完成之后信號量完成
func producer(wg *sync.WaitGroup, products chan- Product, name int, stop *bool) {
for !*stop {
product := Product{name: name, value: rand.Int()}
products - product
fmt.Printf("producer %v produce a product: %#v\n", name, product)
time.Sleep(time.Duration(200+rand.Intn(1000)) * time.Millisecond)
}
wg.Done()
}
消費者
不斷地從通道里面取 product，然后作對應(yīng)的處理，直到通道被關(guān)閉，并且 products 里面為空， for 循環(huán)才會終止，而這正是我們期望的
func consumer(wg *sync.WaitGroup, products -chan Product, name int) {
for product := range products {
fmt.Printf("consumer %v consume a product: %#v\n", name, product)
time.Sleep(time.Duration(200+rand.Intn(1000)) * time.Millisecond)
}
wg.Done()
}
主線程
var wgp sync.WaitGroup
var wgc sync.WaitGroup
stop := false
products := make(chan Product, 10)
// 創(chuàng)建 5 個生產(chǎn)者和 5 個消費者
for i := 0; i 5; i++ {
go producer(wgp, products, i, stop)
go consumer(wgc, products, i)
wgp.Add(1)
wgc.Add(1)
}
time.Sleep(time.Duration(1) * time.Second)
stop = true // 設(shè)置生產(chǎn)者終止信號
wgp.Wait() // 等待生產(chǎn)者退出
close(products) // 關(guān)閉通道
wgc.Wait() // 等待消費者退出
補充：Go并發(fā)編程--通過channel實現(xiàn)生產(chǎn)者消費者模型
概述
生產(chǎn)者消費者模型是多線程設(shè)計的經(jīng)典模型，該模型被廣泛的應(yīng)用到各個系統(tǒng)的多線程/進程模型設(shè)計中。
本文介紹了Go語言中channel的特性，并通過Go語言實現(xiàn)了兩個生產(chǎn)者消費者模型。
channel的一些特性
在Go中channel是非常重要的協(xié)程通信的手段，channel是雙向的通道，通過channel可以實現(xiàn)協(xié)程間數(shù)據(jù)的傳遞，通過channel也可以實現(xiàn)協(xié)程間的同步（后面會有介紹）。
本文介紹的生產(chǎn)者消費者模型主要用到了channel的以下特性：任意時刻只能有一個協(xié)程能夠?qū)hannel中某一個item進行訪問。
單生產(chǎn)者單消費者模型
把生產(chǎn)者和消費者都放到一個無線循環(huán)中，這個和我們的服務(wù)器端的任務(wù)處理非常相似。生產(chǎn)者不斷的向channel中放入數(shù)據(jù)，而消費者不斷的從channel中取出數(shù)據(jù)，并對數(shù)據(jù)進行處理（打印）。
由于生產(chǎn)者的協(xié)程不會退出，所以channel的寫入會永久存在，這樣當(dāng)channel中沒有放入數(shù)據(jù)時，消費者端將會阻塞，等待生產(chǎn)者端放入數(shù)據(jù)。
代碼的實現(xiàn)如下：
package main
import (
"fmt"
"time"
)
var ch1 chan int = make(chan int)
var bufChan chan int = make(chan int, 1000)
var msgChan chan int = make(chan int)
func sum(a int, b int) {
ch1 - a + b
}
// write data to channel
func writer(max int) {
for {
for i := 0; i max; i++ { // 簡單的向channel中放入一個整數(shù)
bufChan - i
time.Sleep(1 * time.Millisecond) //控制放入的頻率
}
}
}
// read data fro m channel
func reader(max int) {
for {
r := -bufChan
fmt.Printf("read value: %d\n", r)
}
// 通知主線程，工作結(jié)束了，這一步可以省略
msgChan - 1
}
func testWriterAndReader(max int) {
go writer(max)
go reader(max)
// writer 和reader的任務(wù)結(jié)束了，主線程會得到通知
res := -msgChan
fmt.Printf("task is done: value=%d\n", res)
}
func main() {
testWriterAndReader(100)
}
多生產(chǎn)者消費者模型
我們可以利用channel在某個時間點只能有一個協(xié)程能夠訪問其中的某一個數(shù)據(jù)，的特性來實現(xiàn)生產(chǎn)者消費者模型。由于channel具有這樣的特性，我們在放數(shù)據(jù)和消費數(shù)據(jù)時可以不需要加鎖。
package main
import (
"time"
"fmt"
"os"
)
var ch1 chan int = make(chan int)
var bufChan chan int = make(chan int, 1000)
var msgChan chan string = make(chan string)
func sum(a int, b int) {
ch1 - a + b
}
// write data to channel
func writer(max int) {
for {
for i := 0; i max; i++ {
bufChan - i
fmt.Fprintf(os.Stderr, "%v write: %d\n", os.Getpid(), i)
time.Sleep(10 * time.Millisecond)
}
}
}
// read data fro m channel
func reader(name string) {
for {
r := -bufChan
fmt.Printf("%s read value: %d\n", name, r)
}
msgChan - name
}
func testWriterAndReader(max int) {
// 開啟多個writer的goroutine，不斷地向channel中寫入數(shù)據(jù)
go writer(max)
go writer(max)
// 開啟多個reader的goroutine，不斷的從channel中讀取數(shù)據(jù)，并處理數(shù)據(jù)
go reader("read1")
go reader("read2")
go reader("read3")
// 獲取三個reader的任務(wù)完成狀態(tài)
name1 := -msgChan
name2 := -msgChan
name3 := -msgChan
fmt.Println("%s,%s,%s: All is done!!", name1, name2, name3)
}
func main() {
testWriterAndReader(100)
}
輸出如下：
read3 read value: 0
80731 write: 0
80731 write: 0
read1 read value: 0
80731 write: 1
read2 read value: 1
80731 write: 1
read3 read value: 1
80731 write: 2
read2 read value: 2
80731 write: 2
... ...
總結(jié)
本文通過channel實現(xiàn)了經(jīng)典的生產(chǎn)者和消費者模型，利用了channel的特性。但要注意，當(dāng)消費者的速度小于生產(chǎn)者時，channel就有可能產(chǎn)生擁塞，導(dǎo)致占用內(nèi)存增加，所以，在實際場景中需要考慮channel的緩沖區(qū)的大小。
設(shè)置了channel的大小，當(dāng)生產(chǎn)的數(shù)據(jù)大于channel的容量時，生產(chǎn)者將會阻塞，這些問題都是要在實際場景中需要考慮的。
一個解決辦法就是使用一個固定的數(shù)組或切片作為環(huán)形緩沖區(qū)，而非channel，通過Sync包的機制來進行同步，實現(xiàn)生產(chǎn)者消費者模型，這樣可以避免由于channel滿而導(dǎo)致消費者端阻塞。
但，對于環(huán)形緩沖區(qū)而言，可能會覆蓋老的數(shù)據(jù)，同樣需要考慮具體的使用場景。關(guān)于環(huán)形緩沖區(qū)的原理和實現(xiàn)，在分析Sync包的使用時再進一步分析。
以上為個人經(jīng)驗，希望能給大家一個參考，也希望大家多多支持腳本之家。如有錯誤或未考慮完全的地方，望不吝賜教。
您可能感興趣的文章:- golang并發(fā)編程的實現(xiàn)
- Go并發(fā)編程實踐
- GO語言并發(fā)編程之互斥鎖、讀寫鎖詳解
- Golang Goroutine的使用
- Go語言學(xué)習(xí)之goroutine詳解
- Go并發(fā)編程之正確使用goroutine的方法
