go等待一組協(xié)程結(jié)束的操作方式
go提供了sync包和channel來解決協(xié)程同步和通訊。
方式1:
sync.WaitGroup是等待一組協(xié)程結(jié)束，sync.WaitGroup只有3個方法，Add()添加一個計數(shù)，Done()減去一個計數(shù)，Wait()阻塞直到所有任務(wù)完成。
package main
import (
"fmt"
"sync"
"time"
)
var wg sync.WaitGroup //定義一個同步等待的組
func task(i int){
fmt.Println("task...",i)
//耗時操作任務(wù)，網(wǎng)絡(luò)請求，讀取文件
time.Sleep(time.Second)
wg.Done() //減去一個計數(shù)
}
func main(){
for i:= 0;i<10;i++{
wg.Add(1) //添加一個計數(shù)
go task(i)
}
wg.Wait() //阻塞直到所有任務(wù)完成
fmt.Println("over")
}
運行結(jié)果：
task... 9
task... 4
task... 6
task... 0
task... 7
task... 5
task... 1
task... 2
task... 8
task... 3
over
方式2:
利用緩沖信道channel協(xié)程之間通訊，其阻塞等待功能實現(xiàn)等待一組協(xié)程結(jié)束，不能保證其goroutine按照順序執(zhí)行
package main
import (
"fmt"
)
var ch = make(chan int,10)
func task(i int){
fmt.Println("task...",i)
ch <- i
}
func main(){
for i:= 0;i<10;i++{
go task(i)
}
for i:= 0;i<10;i++{
<- ch
}
fmt.Println("over")
}
運行結(jié)果：
task... 9
task... 0
task... 1
task... 2
task... 6
task... 7
task... 3
task... 4
task... 8
task... 5
over
方式3:
利用無緩沖的信道channel協(xié)程之間通訊，其阻塞等待功能實現(xiàn)等待一組協(xié)程結(jié)束，保證了其goroutine按照順序執(zhí)行
package main
import (
"fmt"
"time"
)
var ch = make(chan int)
func task(i int){
fmt.Println("task...",i)
time.Sleep(time.Second)
<- ch
}
func main(){
for i:= 0;i<10;i++{
go task(i)
ch <- i
}
fmt.Println("over")
}
運行結(jié)果：
task... 0
task... 1
task... 2
task... 3
task... 4
task... 5
task... 6
task... 7
task... 8
task... 9
over
補(bǔ)充：Go中使用Channel等待所有協(xié)程結(jié)束
讓main方法等待所有協(xié)程執(zhí)行完畢再退出?？赡芤话闼悸肥窃O(shè)置一個共有變量，然后通過修改這個變量的狀態(tài)。這是通過共享變量來通信的方式，而go要做的是，通過通信來共享內(nèi)存。
1. 按順序執(zhí)行
每次通信進(jìn)行成對通信，當(dāng)main向協(xié)程發(fā)送一個寫channel時，同時也等待協(xié)程返回一個讀channel。
這兩個channel一定是成對的，所以構(gòu)造一個結(jié)構(gòu)體
type worker struct {
in chan int
done chan bool
}
func chanDemo1(){
var workers [10]worker
for i := 0; i < 10; i++ {
workers[i] = createWorker1(i)
}
for i := 0; i < 10; i++ {
workers[i].in <- 'a' + i
<- workers[i].done
}
for i := 0; i < 10; i++ {
workers[i].in <- 'A' + i
<- workers[i].done
}
}
func createWorker1(id int) worker {
work := worker{
in: make(chan int),
done: make(chan bool),
}
go func() {
for {
fmt.Printf("Work %d receiverd %c\n", id, <- work.in)
work.done <- true
}
}()
return work
}
func main(){
chanDemo1()
fmt.Println("over")
}
這個執(zhí)行結(jié)果完全是按照0-9，先小寫再大寫的順序
如果這樣順序執(zhí)行，還要協(xié)程干啥
2. 批量處理
type worker struct {
in chan int
done chan bool
}
func chanDemo1(){
var workers [10]worker
for i := 0; i < 10; i++ {
workers[i] = createWorker1(i)
}
for i := 0; i < 10; i++ {
workers[i].in <- 'a' + i
}
for _, worker := range workers {
<- worker.done
}
for i := 0; i < 10; i++ {
workers[i].in <- 'A' + i
}
for _, worker := range workers {
<- worker.done
}
}
func createWorker1(id int) worker {
work := worker{
in: make(chan int),
done: make(chan bool),
}
go func() {
for {
fmt.Printf("Work %d receiverd %c\n", id, <- work.in)
work.done <- true
}
}()
return work
}
這樣的話，先打印小寫，再打印大寫，但是大小寫時順序不固定
3. 完全隨機(jī)
func chanDemo1(){
var workers [10]worker
for i := 0; i < 10; i++ {
workers[i] = createWorker1(i)
}
for i := 0; i < 10; i++ {
workers[i].in <- 'a' + i
}
for i := 0; i < 10; i++ {
workers[i].in <- 'A' + i
}
for _, worker := range workers {
<- worker.done
<- worker.done
}
}
func createWorker1(id int) worker {
work := worker{
in: make(chan int),
done: make(chan bool),
}
go func() {
for {
fmt.Printf("Work %d receiverd %c\n", id, <- work.in)
// 再開一個協(xié)程
go func() { work.done <- true}()
}
}()
return work
}
這種方式就是完全隨機(jī)了
使用channel進(jìn)行樹的遍歷
func (node *Node) TraverseFunc(f func(*Node)){
if node == nil{
return
}
node.Left.TraverseFunc(f)
f(node)
node.Right.TraverseFunc(f)
}
func (node *Node) TraverseWithChannel() chan *Node{
out := make(chan *Node)
go func() {
node.TraverseFunc(func(node *Node) {
out <- node
})
close(out)
}()
return out
}
func main(){
var root Node
root = Node{Value:3}
root.Left = &Node{}
root.Right = &Node{5,nil,nil}
root.Right.Left = new(Node)
root.Left.Right =&Node{6,nil,nil}
root.Traverse()
c:=root.TraverseWithChannel()
maxNode := 0
for node := range c{
if node.Value > maxNode{
maxNode = node.Value
}
}
fmt.Println("max node value:", maxNode)
以上為個人經(jīng)驗，希望能給大家一個參考，也希望大家多多支持腳本之家。如有錯誤或未考慮完全的地方，望不吝賜教。
相關(guān)文章
golang通過context控制并發(fā)的應(yīng)用場景實現(xiàn)
這篇文章主要介紹了golang通過context控制并發(fā)的應(yīng)用場景實現(xiàn)，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2020-01-01
7分鐘讀懂Go的臨時對象池pool以及其應(yīng)用場景
這篇文章主要給大家介紹了關(guān)于如何通過7分鐘讀懂Go的臨時對象池pool以及其應(yīng)用場景的相關(guān)資料，文中通過示例代碼介紹的非常詳細(xì)，對大家學(xué)習(xí)或使用Go具有一定的參考學(xué)習(xí)價值，需要的朋友們下面來一起看看吧2018-11-11
基于Golang實現(xiàn)Redis協(xié)議解析器
這篇文章主要為大家詳細(xì)介紹了如何通過GO語言編寫簡單的Redis協(xié)議解析器，文中的示例代碼講解詳細(xì)，對我們深入了解Go語言有一定的幫助，需要的可以參考一下2023-03-03
這篇文章主要介紹了Go語言操作mysql數(shù)據(jù)庫簡單例子,本文包含插入數(shù)據(jù)和查詢代碼實例,需要的朋友可以參考下2014-10-10
這篇文章主要為大家介紹了Go常量基礎(chǔ)概念包括常量的聲明更改只讀,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進(jìn)步,早日升職加薪2023-08-08
go?sync包中的互斥鎖Mutex和等待組WaitGroup使用詳解
這篇文章主要為大家介紹了go?sync包中的互斥鎖Mutex和等待組WaitGroup使用詳解,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進(jìn)步,早日升職加薪2023-08-08
策略是一種行為設(shè)計模式,?它將一組行為轉(zhuǎn)換為對象,?并使其在原始上下文對象內(nèi)部能夠相互替換,本文就將通過代碼示例給大家詳細(xì)的介紹一下Go的策略模式,需要的朋友可以參考下2023-08-08
淺談golang for 循環(huán)中使用協(xié)程的問題
這篇文章主要介紹了淺談golang for 循環(huán)中使用協(xié)程的問題，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-12-12
這篇文章主要為大家詳細(xì)介紹了Go語言中接口應(yīng)用模式或慣例介紹的相關(guān)知識,文中的示例代碼講解詳細(xì),有需要的小伙伴可以跟隨小編一起學(xué)習(xí)一下2023-11-11
這篇文章主要介紹了GO的方法值和方法表達(dá)式的使用方法，本文通過實例代碼給大家介紹的非常詳細(xì)，具有一定的參考借鑒價值,需要的朋友可以參考下2020-02-02