轉載自：

http://blog.csdn.net/skh2015java/article/details/60330785

http://blog.csdn.net/skh2015java/article/details/60330875

http://blog.csdn.net/skh2015java/article/details/60330975

如果不是我對真正並行的執行緒的追求，就不會認識到Go有多麼的迷人。

Go語言從語言層面上就支援了併發，這與其他語言大不一樣，不像以前我們要用Thread庫來新建執行緒，還要用執行緒安全的佇列庫來共享資料。

以下是我入門的學習筆記。

Go語言的goroutines、通道和死鎖

goroutine

Go語言中有個概念叫做goroutine, 這類似我們熟知的執行緒，但是更輕。

以下的程式，我們序列地去執行兩次loop函式:

func loop() {
    for i := 0; i < 10; i++ {
        fmt.Printf("%d ", i)
    }
}


func main() {
    loop()
    loop()
}

毫無疑問，輸出會是這樣的:

0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9

下面我們把一個loop放在一個goroutine裡跑，我們可以使用關鍵字go

來定義並啟動一個goroutine:

func main() {
    go loop() // 啟動一個goroutine
    loop()
}

這次的輸出變成了:

0 1 2 3 4 5 6 7 8 9

可是為什麼只輸出了一趟呢？明明我們主線跑了一趟，也開了一個goroutine來跑一趟啊。

原來，在goroutine還沒來得及跑loop的時候，主函式已經退出了。

main函式退出地太快了，我們要想辦法阻止它過早地退出，一個辦法是讓main等待一下:

func main() {
    go loop()
    loop()
    time 
.Sleep(time.Second) // 停頓一秒
}

這次確實輸出了兩趟，目的達到了。

可是採用等待的辦法並不好，如果goroutine在結束的時候，告訴下主線說“Hey, 我要跑完了！”就好了，即所謂阻塞主線的辦法，回憶下我們Python裡面等待所有執行緒執行完畢的寫法:

for thread in threads:
    thread.join()

是的，我們也需要一個類似join的東西來阻塞住主線。那就是通道

通道

通道是什麼？簡單說，是goroutine之間互相通訊的東西。類似我們Unix上的管道（可以在程序間傳遞訊息），用來goroutine之間發訊息和接收訊息。其實，就是在做goroutine之間的記憶體共享。

使用make來建立一個通道:

var channel chan int = make(chan int)
// 或
channel := make(chan int)

那如何向通道存訊息和取訊息呢？一個例子:

func main() {
    var messages chan string = make(chan string)
    go func(message string) {
        messages <- message // 存訊息
    }("Ping!")

    fmt.Println(<-messages) // 取訊息
}

預設的，通道的存訊息和取訊息都是阻塞的 (叫做無緩衝的通道，不過緩衝這個概念稍後瞭解，先說阻塞的問題)。

也就是說, 無緩衝的通道在取訊息和存訊息的時候都會掛起當前的goroutine，除非另一端已經準備好。

比如以下的main函式和foo函式:

var ch chan int = make(chan int)

func foo() {
    ch <- 0  // 向ch中加資料，如果沒有其他goroutine來取走這個資料，那麼掛起foo, 直到main函式把0這個資料拿走
}

func main() {
    go foo()
    <- ch // 從ch取資料，如果ch中還沒放資料，那就掛起main線，直到foo函式中放資料為止
}

那既然通道可以阻塞當前的goroutine, 那麼回到上一部分「goroutine」所遇到的問題「如何讓goroutine告訴主線我執行完畢了」的問題來, 使用一個通道來告訴主線即可:

var complete chan int = make(chan int)

func loop() {
    for i := 0; i < 10; i++ {
        fmt.Printf("%d ", i)
    }

    complete <- 0 // 執行完畢了，發個訊息
}


func main() {
    go loop()
    <- complete // 直到執行緒跑完, 取到訊息. main在此阻塞住
}

如果不用通道來阻塞主線的話，主線就會過早跑完，loop線都沒有機會執行

其實，無緩衝的通道永遠不會儲存資料，只負責資料的流通，為什麼這麼講呢？

從無緩衝通道取資料，必須要有資料流進來才可以，否則當前線阻塞
資料流入無緩衝通道, 如果沒有其他goroutine來拿走這個資料，那麼當前線阻塞

所以，你可以測試下，無論如何，我們測試到的無緩衝通道的大小都是0 (len(channel))

如果通道正有資料在流動，我們還要加入資料，或者通道乾澀，我們一直向無資料流入的空通道取資料呢？就會引起死鎖

死鎖

一個死鎖的例子:

func main() {
    ch := make(chan int)
    <- ch // 阻塞main goroutine, 通道c被鎖
}

執行這個程式你會看到Go報這樣的錯誤:

fatal error: all goroutines are asleep - deadlock!

何謂死鎖? 作業系統有講過的，所有的執行緒或程序都在等待資源的釋放。如上的程式中, 只有一個goroutine, 所以當你向裡面加資料或者存資料的話，都會鎖死通道，並且阻塞當前 goroutine, 也就是所有的goroutine(其實就main線一個)都在等待通道的開放(沒人拿走資料通道是不會開放的)，也就是死鎖咯。

我發現死鎖是一個很有意思的話題，這裡有幾個死鎖的例子:

只在單一的goroutine裡操作無緩衝通道，一定死鎖。比如你只在main函式裡操作通道:

func main() {
    ch := make(chan int)
    ch <- 1 // 1流入通道，堵塞當前線, 沒人取走資料通道不會開啟
    fmt.Println("This line code wont run") //在此行執行之前Go就會報死鎖
}

如下也是一個死鎖的例子:

var ch1 chan int = make(chan int)
var ch2 chan int = make(chan int)

func say(s string) {
    fmt.Println(s)
    ch1 <- <- ch2 // ch1 等待 ch2流出的資料
}

func main() {
    go say("hello")
    <- ch1  // 堵塞主線
}

其中主線等ch1中的資料流出，ch1等ch2的資料流出，但是ch2等待資料流入，兩個goroutine都在等，也就是死鎖。

其實，總結來看，為什麼會死鎖？非緩衝通道上如果發生了流入無流出，或者流出無流入，也就導致了死鎖。或者這樣理解 Go啟動的所有goroutine裡的非緩衝通道一定要一個線裡存資料，一個線裡取資料，要成對才行。所以下面的示例一定死鎖:
```
c, quit := make(chan int), make(chan int)

go func() {
   c <- 1  // c通道的資料沒有被其他goroutine讀取走，堵塞當前goroutine
   quit <- 0 // quit始終沒有辦法寫入資料
}()

<- quit // quit 等待資料的寫
```
仔細分析的話，是由於：主線等待quit通道的資料流出，quit等待資料寫入，而func被c通道堵塞，所有goroutine都在等，所以死鎖。

簡單來看的話，一共兩個線，func線中流入c通道的資料並沒有在main線中流出，肯定死鎖。

但是，是否果真所有不成對向通道存取資料的情況都是死鎖?

如下是個反例:

func main() {
    c := make(chan int)

    go func() {
       c <- 1
    }()
}

程式正常退出了，很簡單，並不是我們那個總結不起作用了，還是因為一個讓人很囧的原因，main又沒等待其它goroutine，自己先跑完了，所以沒有資料流入c通道，一共執行了一個goroutine, 並且沒有發生阻塞，所以沒有死鎖錯誤。

那麼死鎖的解決辦法呢？

最簡單的，把沒取走的資料取走，沒放入的資料放入，因為無緩衝通道不能承載資料，那麼就趕緊拿走！

具體來講，就死鎖例子3中的情況，可以這麼避免死鎖:

c, quit := make(chan int), make(chan int)

go func() {
    c <- 1
    quit <- 0
}()

<- c // 取走c的資料！
<-quit

另一個解決辦法是緩衝通道, 即設定c有一個數據的緩衝大小:

c := make(chan int, 1)

這樣的話，c可以快取一個數據。也就是說，放入一個數據，c並不會掛起當前線, 再放一個才會掛起當前線直到第一個資料被其他goroutine取走, 也就是隻阻塞在容量一定的時候，不達容量不阻塞。

這十分類似我們Python中的佇列Queue不是嗎？

無緩衝通道的資料進出順序

我們已經知道，無緩衝通道從不儲存資料，流入的資料必須要流出才可以。

觀察以下的程式:

var ch chan int = make(chan int)

func foo(id int) { //id: 這個routine的標號
    ch <- id
}

func main() {
    // 開啟5個routine
    for i := 0; i < 5; i++ {
        go foo(i)
    }

    // 取出通道中的資料
    for i := 0; i < 5; i++ {
        fmt.Print(<- ch)
    }
}

我們開了5個goroutine，然後又依次取資料。其實整個的執行過程細分的話，5個線的資料依次流過通道ch, main列印之, 而巨集觀上我們看到的即無緩衝通道的資料是先到先出，但是無緩衝通道並不儲存資料，只負責資料的流通

緩衝通道

終於到了這個話題了, 其實快取通道用英文來講更為達意: buffered channel.

緩衝這個詞意思是，緩衝通道不僅可以流通資料，還可以快取資料。它是有容量的，存入一個數據的話 , 可以先放在信道里，不必阻塞當前線而等待該資料取走。

當緩衝通道達到滿的狀態的時候，就會表現出阻塞了，因為這時再也不能承載更多的資料了，「你們必須把資料拿走，才可以流入資料」。

在宣告一個通道的時候，我們給make以第二個引數來指明它的容量(預設為0，即無緩衝):

var ch chan int = make(chan int, 2) // 寫入2個元素都不會阻塞當前goroutine, 儲存個數達到2的時候會阻塞

如下的例子，緩衝通道ch可以緩衝的流入3個元素:

func main() {
    ch := make(chan int, 3)
    ch <- 1
    ch <- 2
    ch <- 3
}

如果你再試圖流入一個數據的話，通道ch會阻塞main線, 報死鎖。

也就是說，緩衝通道會在滿容量的時候加鎖。

其實，緩衝通道是先進先出的，我們可以把緩衝通道看作為一個執行緒安全的佇列：

golang語言併發與並行——goroutine和channel的詳細理解

Go語言的goroutines、通道和死鎖

goroutine

通道

死鎖

無緩衝通道的資料進出順序

緩衝通道