程序運算時往往需要數(shù)據(jù)，而數(shù)據(jù)的IO又往往需要時間傳輸，而常見的串行處理，是一個任務(wù)處理完成才接著處理新的任務(wù)， 其效率低下可想而知。 假如有3個任務(wù)要處理，而每個任務(wù)都有一定的阻塞，串行處理大概是這個樣子:
main.go
package main
import (
"fmt"
"time"
)
type Task struct {
Duration time.Duration
Name string
}
func main() {
// 聲明要處理的任務(wù)
taskList := []Task {
{
1,
"處理1",
},
{
2,
"處理2",
},
{
3,
"處理3",
},
}
starTime := time.Now().Unix()
for _, item := range taskList {
goProcess(item)
}
fmt.Printf("用時:%ds\n", time.Now().Unix() - starTime)
}
/**
* 進(jìn)行處理
*/
func goProcess(task Task) {
time.Sleep(time.Second * task.Duration) // 假設(shè)這是io阻塞會在這里阻塞一些時間，而這些io可能是網(wǎng)絡(luò)io也可能是磁盤io等，io完成后才會接著運行下去
fmt.Printf("任務(wù):%s 處理完畢\n", task.Name)
}
處理打印結(jié)果
任務(wù):處理1 處理完畢
任務(wù):處理2 處理完畢
任務(wù):處理3 處理完畢
用時:6s
這種串行處理遇到IO阻塞時，弊端就是太費時間了
可以看到，程序在計算時或許用不到多少時間反而是IO阻塞占用了大量的時間。這種占著茅坑不拉屎，外面等著人直跳腳，確實不太好。而用異步處理則可以跳過阻塞，達(dá)到避免占坑的情況發(fā)生。
用協(xié)程的話，則可以在阻塞時先異步執(zhí)行下去而不用等待，等所有協(xié)程都處理結(jié)束，再把處理的結(jié)果匯總起來就可以了，代碼大概是這樣子：
main.go
package main
import (
"fmt"
"sync"
"time"
)
type Task struct {
Duration time.Duration
Name string
}
func main() {
// 聲明要處理的任務(wù)
taskList := []Task {
{
1,
"處理1",
},
{
2,
"處理2",
},
{
3,
"處理3",
},
}
starTime := time.Now().Unix()
var res []string //處理結(jié)果收集
resChang := make(chan string, len(taskList))
wg := sync.WaitGroup{}
// 這里收集異步處理的結(jié)果, 通過管道把數(shù)據(jù)傳遞過來，類似于單一訂閱功能吧
go func() {
wg.Add(1)
defer wg.Done() // 通道關(guān)閉后 處理結(jié)果也收集完畢，則觸發(fā) 用于通知下方批處理，處理結(jié)果已經(jīng)收集完畢
for resItem := range resChang {
res = append(res, resItem)
}
}()
taskWG := sync.WaitGroup{}
for _, item := range taskList {
taskWG.Add(1) // 批處理 信號量+1
go goProcess(item, resChang, taskWG)
}
taskWG.Wait()// 這里阻塞，等待所有處理執(zhí)行完畢, 才接著運行下去
close(resChang)// 已經(jīng)處理完畢后就關(guān)閉處理傳輸通道
wg.Wait() // 這是阻塞 等待處理收集完畢, 才接著運行去
// 打印批處理收集的處理結(jié)果
for _, i := range res {
fmt.Printf("%s", i)
}
fmt.Printf("用時:%ds\n", time.Now().Unix() - starTime)
}
/**
* 進(jìn)行處理
*/
func goProcess(task Task, resChan *chan string, taskWG *sync.WaitGroup) {
time.Sleep(time.Second * task.Duration) // 假設(shè)這是io阻塞會在這里阻塞一些時間，而這些io可能是網(wǎng)絡(luò)io也可能是磁盤io等，才會接著運行下去
res := fmt.Sprintf("任務(wù):%s 處理完畢\n", task.Name)
defer func() {
*resChan - res // 把處理結(jié)果傳出去
taskWG.Done() // 批處理信號量-1 來報告處理完畢
}()
}
運行結(jié)果
任務(wù):處理1 處理完畢
任務(wù):處理2 處理完畢
任務(wù):處理3 處理完畢
用時:3s
相對于之前的串行，這次的并行有效處理IO的阻塞，相當(dāng)于，串行就是占坑不用的角，并行則不管這些，你不用，先把你踹開，給有需要的人用先，這樣一腳腳的踹，效率就上一來了。
到此這篇關(guān)于golang的串行處理和并行處理實現(xiàn)的文章就介紹到這了,更多相關(guān)golang 串行處理和并行處理內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
您可能感興趣的文章:- golang中的并發(fā)和并行
- go語言channel實現(xiàn)多核并行化運行的方法
