需求： 模擬兩個協程，分別循環打印字母A和B。
分析： 要實現兩個協程之間的交替協作，就必須用到channel通信機制，而channel正好是同步阻塞的。
半開方式
首先我們用一個channel變量來控制兩個goroutine的交替打印：
func main() {
exit := make(chan bool)
ch1 := make(chan int)
go func() {
for i := 1; i = 10; i++ {
ch1 - 0 //生產
fmt.Println("A",i)
}
exit - true
}()
go func() {
for i := 1; i = 10; i++ {
-ch1 //消費
fmt.Println("B",i)
}
}()
-exit
}
結果發現打印出了ABBAABBA...的效果。
也就是我們控制了開始的次序，但沒有控制結束的次序，發生了并發不安全的情況。
其實半開模式也可以用于某些場景下，如: 兩個goroutine，在條件控制下，交替打印奇偶數：
func main() {
exit := make(chan bool)
ch1 := make(chan int)
go func() {
for i := 1; i = 10; i++ {
ch1 - 0
if i%2 == 0 {
fmt.Println("A", i)
}
}
exit - true
}()
go func() {
for i := 1; i = 10; i++ {
-ch1
if i%2 == 1 {
fmt.Println("B", i)
}
}
}()
-exit
}
封閉方式
接下來我們使用兩個channel變量來模擬goroutine循環體的互斥問題。
func main() {
exit := make(chan bool)
ch1, ch2 := make(chan bool), make(chan bool)
go func() {
for i := 1; i = 10; i++ {
ch1 - true
fmt.Println("A", i)
//在ch1和ch2之間是阻塞獨占的
-ch2
}
exit - true
}()
go func() {
for i := 1; i = 10; i++ {
-ch1
fmt.Println("B", i)
ch2 - true
}
}()
-exit
}
我們在循環體首尾都使用了阻塞獨占模式，兩個chan交替釋放控制權，達到了安全的協程交互控制。
再看看下面的Demo，同樣的原理：
func main(){
ch1 :=make(chan int)
ch2 :=make(chan string)
str :=[5]string{"a","b","c","d","e"}
go func() {
for i:=0;i5;i++{
ch1-i
fmt.Print(i+1)
-ch2
}
}()
for _,v :=range str{
-ch1
fmt.Print(v)
ch2-v
}
}
緩沖模式
緩沖模式和封閉模式相似，只是封閉模式中，兩個goroutine有明確的首尾角色。而緩沖模式的第一生產者交給了主協程，兩個goroutine結構一樣，輪式交換角色。
func main() {
exit := make(chan bool)
ch1, ch2 := make(chan bool,1), make(chan bool)
ch1 - true //生產(選擇一個啟動項)
go func() {
for i := 1; i = 10; i++ {
if ok := -ch1; ok { //消費
fmt.Println("A", 2*i-1)
ch2 - true //生產
}
}
}()
go func() {
defer func() { close(exit) }()
for i := 1; i = 10; i++ {
if ok := -ch2; ok { //消費
fmt.Println("B", 2*i)
ch1 - true //生產
}
}
}()
-exit
}
結論：
Channel的本質就是同步式的生產消費模式
補充：go 讓N個協程交替打印1-100
今天遇到一道面試題，開啟N個協程，并交替打印1-100如給定N=3則輸出:
goroutine0: 0
goroutine1: 1
goroutine2: 2
goroutine0: 3
goroutine1: 4
面試時沒答案，雖過后研究參考了一些網上方法，并記錄下來，先上代碼
func print() {
chanNum := 3 // chan 數量
chanQueue := make([]chan int, chanNum) // 創建chan Slice
var result = 0 // 值
exitChan := make(chan bool) // 退出標識
for i := 0; i chanNum; i++ {
// 創建chan
chanQueue[i] = make(chan int)
if i == chanNum-1 {
// 給最后一個chan寫一條數據，為了第一次輸出從第1個chan輸出
go func(i int) {
chanQueue[i] - 1
}(i)
}
}
for i := 0; i chanNum; i++ {
var lastChan chan int // 上一個goroutine 結束才能輸出 控制輸出順序
var curChan chan int // 當前阻塞輸出的goroutine
if i == 0 {
lastChan = chanQueue[chanNum-1]
} else {
lastChan = chanQueue[i-1]
}
curChan = chanQueue[i]
go func(i int, lastChan, curChan chan int) {
for {
if result > 100 {
// 超過100就退出
exitChan - true
}
// 一直阻塞到上一個輸出完，控制順序
-lastChan
fmt.Printf("thread%d: %d \n", i, result)
result = result + 1
// 當前goroutine已輸出
curChan - 1
}
}(i, lastChan, curChan)
}
-exitChan
fmt.Println("done")
}
1、第一個for循環創建chan
2、第二個for循環里的lastChan意思是，當前chan如果要打印數據，就必須得上一個chan打印完后才能打印。
這里假設N=2，chan索引為0,1，當索引1要輸出,就阻塞到索引0的chan有數據為止，當自己打印完后往自己的chan中發送一個1,方便給依賴自己的chan 解除阻塞。
這里有個特殊的地方，當索引為0時，他的依賴索引chan就為chanQueue的長度-1，如果沒有在創建Chan中的時候沒有下面這一串代碼就會造成死鎖
if i == chanNum-1 {
// 給最后一個chan寫一條數據，為了第一次輸出從第1個chan輸出
go func(i int) {
chanQueue[i] - 1
}(i)
}
以上為個人經驗，希望能給大家一個參考，也希望大家多多支持腳本之家。如有錯誤或未考慮完全的地方，望不吝賜教。
您可能感興趣的文章:- Go 并發實現協程同步的多種解決方法
- go等待一組協程結束的操作方式
- golang協程池模擬實現群發郵件功能
- 解決go在函數退出后子協程的退出問題
- Golang 之協程的用法講解
- go 協程返回值處理操作
- 淺談golang for 循環中使用協程的問題
- Go并發:使用sync.WaitGroup實現協程同步方式
