go語言中的協程實例分析

這篇文章主要講解了“go語言中的協程實例分析”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“go語言中的協程實例分析”吧！

協程的特點

1.該任務的業務代碼主動要求切換，即主動讓出執行權限

2.發生了IO，導致執行阻塞（使用channel讓協程阻塞）

與線程本質的不同

C#、java中我們執行多個線程，是通過時間片切換來進行的，要知道進行切換，程序需要保存上下文等信息，是比較消耗性能的

GO語言中的協程，沒有上面這種切換，一定是通過協程主動放出權限，不是被動的。

例如：

C# 中創建兩個線程

可以看到1和2是交替執行的

Go語言中用協程實現一下

runtime.GOMAXPROCS(1)

這個結果就是 執行了1 在執行2

上述兩種方式來進行協程的切換

• 1.該任務的業務代碼主動要求切換，即主動讓出執行權限

• 2.通過channel進行阻塞

執行的結果一樣

后面又繼續執行1了

一、Goroutine的并行

package main

import (
　　"fmt"
　　"runtime"
　　"sync"
)

func main() {
　　runtime.GOMAXPROCS(1)
　　var wg sync.WaitGroup
　　wg.Add(3)
　　fmt.Println("Start Goroutines")

　　go func() {
　　　　defer wg.Done()
　　　　for i:=1;i<=10;i++{
　　　　　　fmt.Print("1")
　　　　}
　　}()

　　go func() {
　　　　defer wg.Done()
　　　　for i:=1;i<=10;i++ {
            fmt.Print("2")
　　　　}
　　}()

　　go func() {
　　　　defer wg.Done()
　　　　for i:=1;i<=10;i++ {
　　         fmt.Print("3")
　　　　}
　　}()

　　fmt.Println("等待執行結束")
　　wg.Wait()
}

運行結果

Start Goroutines

等待執行結束

333333333311111111112222222222

（1）runtime.GOMAXPROCS(1) 的作用是什么？

runtime包的GOMAXPROCS 函數。這個函數允許程序更改調度器可以使用的邏輯處理器的數量。如果不想在代碼里做這個調用，也可以通過修改和這個函數名字一樣的環境變量的值來更改邏輯處理器的數量。

（2）為什么先輸出3后輸出1和2？

調度器源碼中有體現： 有一個隊列，還有一個優先執行——即最后一個， 在只有一個邏輯處理器的情況下，先執行優先的那個，再順序執行隊列中的。不過經過各種實驗發現這個執行順序其實是變的，貌似糾結這個順序也沒有什么意思。

（3）WaitGroup 是什么意思？

WaitGroup 是一個計數信號量，可以用來記錄并維護運行的goroutine。如果WaitGroup的值大于0，Wait 方法就會阻塞。為了減小WaitGroup 的值并最終釋放main 函數，使用defer 聲明在函數退出時

調用Done 方法。（defer 有點像C#當中的fianlly）

補充：調度算法中，如果多個goroutine中某個執行過長，此時會將其停止讓給其他goroutine繼續執行，待到其他都執行完成，在將其進行執行。如下圖：G4和G5就進行了切換

如下代碼可以驗證上面的問題：

package main

import (
    "fmt"
    "runtime"
    "sync"
)

var wg sync.WaitGroup

func main() {
    runtime.GOMAXPROCS(1)

    wg.Add(2)

    fmt.Println("Create Goroutines")
    go printPrime("A")
    go printPrime("B")

    fmt.Println("Waiting To Finish")
    wg.Wait()

    fmt.Println("Terminating Program")
}


func printPrime(prefix string) {
    defer wg.Done()

next:
    for outer := 2; outer < 5000; outer++ {
        for inner := 2; inner < outer; inner++ {
            if outer%inner == 0 {
                continue next
            }
        }
        fmt.Printf("%s:%d\n", prefix, outer)
    }
    fmt.Println("Completed", prefix)
}

printPrime 這個函數作用是查找顯示 5000 以內的素數值，這是一個比較耗時的程序。

運行結果：數字比較多，不打印了，但是可以看到結果是A和B兩個協程之間的切換。

上面的代碼都是設置GOMAXPROCS為1的情況，給每個可用的核心分配一個邏輯處理器

runtime.GOMAXPROCS(runtime.NumCPU())

這樣運行第一個程序的結果如下

Start Goroutines
等待執行結束133333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333332111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222

可以看到1、2、3沒有什么規律。

二、Goroutine的競爭

什么競爭狀態：如果兩個或者多個goroutine 在沒有互相同步的情況下，訪問某個共享的資源，并試圖同時讀和寫這個資源，就處于相互競爭的狀態，這種情況被稱作競爭狀態（race candition）

競爭狀態是比較容易出現問題的地方，所以對一個共享資源的讀和寫操作必須是原子化的，換句話說，同一時刻只能有一個goroutine 對共享資源進行讀和寫操作。

package main

import (
    "fmt"
    "runtime"
    "sync"
)

var (
    counter int
    wg sync.WaitGroup
)

func main() {
    wg.Add(2)

    go incCounter(1)
    go incCounter(2)

    wg.Wait()
    fmt.Println("Final Counter:", counter)
}

func incCounter(id int) {
    defer wg.Done()
    for count := 0; count < 2; count++ {
        value := counter
        runtime.Gosched()
        value++
        counter = value
    }
}

運行結果：

Final Counter: 2

變量 counter 會進行4 次讀和寫操作，每個goroutine 執行兩次。但是，程序終止時，counter變量的值為2，這是因為兩個協程之間產生了競爭，對同一個counter進行讀寫，下面這個圖很好的詮釋了為什么最后counter是2

補充：runtime.Gosched()用于讓出CPU時間片。

三、使用Goroutine的鎖

一種修正代碼、消除競爭狀態的辦法是，使用Go 語言提供的鎖機制，來鎖住共享資源，

從而保證goroutine 的同步狀態。Go 語言提供了傳統的同步goroutine 的機制，就是對共享資源加鎖。

1、原子函數

使用atomic包來提供對數值類型的安全訪問。

package main

import (
    "fmt"
    "runtime"
    "sync"
    "sync/atomic"
)

var (
    counter int64
    wg sync.WaitGroup
)

func main() {
    wg.Add(2)

    go incCounter(1)
    go incCounter(2)

    wg.Wait()

    fmt.Println("Final Counter:", counter)
}

func incCounter(id int) {
    defer wg.Done()
    for count := 0; count < 2; count++ {
        atomic.AddInt64(&counter, 1)
        runtime.Gosched()
    }
}

運行結果

Final Counter: 4

atmoic 包的AddInt64 函數。這個函數會同步整型值的加法，方法是強制同一時刻只能有一個goroutine 運行并完成這個加法操作。當goroutine 試圖去調用任何原子函數時，這些goroutine 都會自動根據所引用的變量做同步處理。

另外兩個有用的原子函數是LoadInt64 和StoreInt64。這兩個函數提供了一種安全地讀和寫一個整型值的方式。

package main

import (
    "fmt"
    "sync"
    "sync/atomic"
    "time"
)

var (
    shutdown int64
    wg sync.WaitGroup
)

func main() {
    wg.Add(2)

    go doWork("A")
    go doWork("B")

    time.Sleep(1 * time.Second)

    fmt.Println("Shutdown Now")
    atomic.StoreInt64(&shutdown, 1)
    wg.Wait()
}

func doWork(name string) {
    defer wg.Done()

    for {
        fmt.Printf("Doing %s Work\n", name)
        time.Sleep(250 * time.Millisecond)

        // Do we need to shutdown.
        if atomic.LoadInt64(&shutdown) == 1 {
            fmt.Printf("Shutting %s Down\n", name)
            break
        }
    }
}

主協程main函數執行了1秒，然后將shutdown中的值設置為1，A和B的協程中通過讀取shutdown是否等于1來判斷是否結束協程。

運行結果：

Doing A Work
Doing B Work
Doing A Work
Doing B Work
Doing A Work
Doing B Work
Doing A Work
Doing B Work
Shutdown Now
Shutting A Down
Shutting B Down

2、互斥鎖

另一種同步訪問共享資源的方式是使用互斥鎖（mutex）。互斥鎖這個名字來自互斥（mutualexclusion）的概念。互斥鎖用于在代碼上創建一個臨界區，保證同一時間只有一個goroutine 可以執行這個臨界區代碼

package main

import (
    "fmt"
    "runtime"
    "sync"
)

var (
    counter int
    wg sync.WaitGroup
    mutex sync.Mutex
)

func main() {
    wg.Add(3)

    go incCounter(1)
    go incCounter(2)
    go incCounter(3)

    wg.Wait()
    fmt.Printf("Final Counter: %d\n", counter)
}

func incCounter(id int) {
    defer wg.Done()

    for count := 0; count < 2; count++ {
        mutex.Lock()
        {
            value := counter
            runtime.Gosched()
            value++
            counter = value
        }
        mutex.Unlock()
    }
}

運行結果：

Final Counter: 6

如上面的代碼，最終的結果還是6.

mutex.lock he mutex.Unlock之間的代碼，同一時刻只允許一個goroutine進入，所以保證數據的正確性。

補充對于 runtime.Gosched()的理解，有兩個問題 1. 當執行了這句話，貌似讓出了執行，那么它后面的語句還能執行么

感謝各位的閱讀，以上就是“go語言中的協程實例分析”的內容了，經過本文的學習后，相信大家對go語言中的協程實例分析這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！