2. 程式人生 > >GO語言使用之channel(管道)

GO語言使用之channel(管道)

阿新 • • 發佈：2018-11-01

一、為什麼需要channel

1、需求：
現在要計算 1-200 的各個數的階乘，並且把各個數的階乘放入到map中。最後顯示出來。要求使用goroutine完成

1)、分析思路：
使用goroutine 來完成，效率高，但是會出現併發/並行安全問題.
這裡就提出了不同goroutine如何通訊的問題

2)、程式碼實現
使用goroutine來完成(看看使用gorotine併發完成會出現什麼問題? 然後我們會去解決)
在執行某個程式時，如何知道是否存在資源競爭問題。 方法很簡單，在編譯該程式時，增加一個引數 -race即可
3)、示意圖
這裡寫圖片描述
4)、程式碼實現：

package
 
 utils


import (
    "sync"
    "fmt"
    "time"
)

// 需求：現在要計算 1-200 的各個數的階乘，並且把各個數的階乘放入到map中。
// 最後顯示出來。要求使用goroutine完成 

// 思路
// 1. 編寫一個函式，來計算各個數的階乘，並放入到 map中.
// 2. 我們啟動的協程多個，統計的將結果放入到 map中
// 3. map 應該做出一個全域性的.

var (
    myMap = make(map[int]int, 10)
)

// cacluFactorial 函式就是計算 n!, 讓將這個結果放入到 myMap
func cacluFactorial(n int
 
) {

    res := 1
    for i := 1; i <= n; i++ {
        res *= i
    }




    //這裡我們將 res 放入到myMap
    myMap[n] = res //concurrent map writes?



}

func FactorialDemo() {

    // 我們這裡開啟多個協程完成這個任務[200個]
    for i := 1; i <= 200; i++ {
        go cacluFactorial(i)
    }


    //休眠10秒鐘【第二個問題 】
    time.Sleep(time.Second * 10
 
)



    //這裡我們輸出結果,變數這個結果
    for i, v := range myMap {
        fmt.Printf("map[%d]=%d\n", i, v)
    }



}

2、不同goroutine之間如何通訊

  • 全域性變數的互斥鎖
  • 使用管道channel來解決

3、使用全域性變數加鎖同步改程序序
因為沒有對全域性變數 m 加鎖，因此會出現資源爭奪問題，程式碼會出現錯誤，提示concurrent map writes
解決方案：加入互斥鎖
我們的數的階乘很大，結果會越界,可以將求階乘改成 sum += uint64(i)
程式碼改進

package utils


import (
    "sync"
    "fmt"
    "time"
)

// 需求：現在要計算 1-200 的各個數的階乘，並且把各個數的階乘放入到map中。
// 最後顯示出來。要求使用goroutine完成 

// 思路
// 1. 編寫一個函式，來計算各個數的階乘，並放入到 map中.
// 2. 我們啟動的協程多個，統計的將結果放入到 map中
// 3. map 應該做出一個全域性的.

var (
    myMap = make(map[int]int, 10)

    /*同步鎖改進程式碼*/
    //宣告一個全域性互斥鎖
    lock sync.Mutex //sync包提供了基本的同步基元，如互斥鎖。Mutex是一個互斥鎖， 
)

// cacluFactorial 函式就是計算 n!, 讓將這個結果放入到 myMap
func cacluFactorial(n int) {

    res := 1
    for i := 1; i <= n; i++ {
        res *= i
    }


    /*同步鎖改進程式碼*/
    lock.Lock()//加鎖

    //這裡我們將 res 放入到myMap
    myMap[n] = res //concurrent map writes?

    lock.Unlock()//解鎖

}

func FactorialDemo() {

    // 我們這裡開啟多個協程完成這個任務[200個]
    for i := 1; i <= 200; i++ {
        go cacluFactorial(i)
    }


    //休眠10秒鐘【第二個問題 】
    time.Sleep(time.Second * 10)

    /*同步鎖改進程式碼*/
    lock.Lock()//加鎖

    //這裡我們輸出結果,變數這個結果
    for i, v := range myMap {
        fmt.Printf("map[%d]=%d\n", i, v)
    }

    lock.Unlock()//解鎖

}

4、為什麼需要channel

前面使用全域性變數加鎖同步來解決goroutine的通訊，但不完美。

主執行緒在等待所有goroutine全部完成的時間很難確定，我們這裡設定10秒，僅僅是估算。

如果主執行緒休眠時間長了，會加長等待時間，如果等待時間短了，可能還有goroutine處於工作狀態，這時也會隨主執行緒的退出而銷燬。

通過全域性變數加鎖同步來實現通訊，也並不利用多個協程對全域性變數的讀寫操作。
上面種種分析都在呼喚一個新的通訊機制-channel

二、channel的基本介紹

1、channle本質就是一個數據結構-佇列
資料是先進先出【FIFO : first in first out】
執行緒安全，多goroutine訪問時，不需要加鎖，就是說channel本身就是執行緒安全的
channel有型別的，一個string的channel只能存放string型別資料。
示意圖：
這裡寫圖片描述
2、定義/宣告channel
語法
var 變數名 chan 資料型別
舉例：

var   intChan   chan  int (intChan用於存放int資料)
var   mapChan chan map[int]string (mapChan用於存放map[int]string型別)
var   perChan  chan  Person 
var   perChan2  chan  *Person

…
說明
channel是引用型別
channel必須初始化才能寫入資料, 即make後才能使用
管道是有型別的，intChan 只能寫入 整數 int

三、快速入門案例

package utils
import (
    "fmt"
)

//管道的初始化，寫入資料到管道，從管道讀取資料及基本的注意事項
func main() {

    //演示一下管道的使用
    //1. 建立一個可以存放3個int型別的管道
    var intChan chan int
    intChan = make(chan int, 3)

    //2. 看看intChan是什麼
    fmt.Printf("intChan 的值=%v intChan本身的地址=%p\n", intChan, &intChan)


    //3. 向管道寫入資料
    intChan<- 10
    num := 211
    intChan<- num
    intChan<- 50
    // intChan<- 98//注意點, 當我們給管寫入資料時，不能超過其容量


    //4. 看看管道的長度和cap(容量)
    fmt.Printf("channel len= %v cap=%v \n", len(intChan), cap(intChan)) // 3, 3

    //5. 從管道中讀取資料

    var num2 int
    num2 = <-intChan 
    fmt.Println("num2=", num2)
    fmt.Printf("channel len= %v cap=%v \n", len(intChan), cap(intChan))  // 2, 3

    //6. 在沒有使用協程的情況下，如果我們的管道資料已經全部取出，再取就會報告 deadlock

    num3 := <-intChan
    num4 := <-intChan
    num5 := <-intChan

    fmt.Println("num3=", num3, "num4=", num4, "num5=", num5)

}

測試結果：

channel len= 3 cap=3
num2= 10
channel len= 2 cap=3
fatal error: all goroutines are asleep - deadlock!

總結：channel使用的注意事項

channel中只能存放指定的資料型別
channle的資料放滿後，就不能再放入了
如果從channel取出資料後，可以繼續放入
在沒有使用協程的情況下，如果channel資料取完了，再取，就會報dead lock

四、channel的遍歷和關閉

1 、channel的關閉
使用內建函式close可以關閉channel, 當channel關閉後，就不能再向channel寫資料了，但是仍然可以從該channel讀取資料

2、channel的遍歷
channel支援for–range的方式進行遍歷，請注意兩個細節
在遍歷時，如果channel沒有關閉，則回出現deadlock的錯誤
在遍歷時，如果channel已經關閉，則會正常遍歷資料，遍歷完後，就會退出遍歷。
3、案列演示

package utils

import (
    "fmt"
)

func TranslateDemo()  {
    intChan := make(chan int, 3)
    intChan<- 100
    intChan<- 200
    close(intChan) // close
    //這是不能夠再寫入數到channel
    //intChan<- 300
    fmt.Println("okook~")
    //當管道關閉後，讀取資料是可以的
    n1 := <-intChan
    fmt.Println("n1=", n1)


    //遍歷管道
    intChan2 := make(chan int, 100)
    for i := 0; i < 100; i++ {
        intChan2<- i * 2  //放入100個數據到管道
    }

    //遍歷管道不能使用普通的 for 迴圈
    // for i := 0; i < len(intChan2); i++ {

    // }
    //在遍歷時，如果channel沒有關閉，則會出現deadlock的錯誤
    //在遍歷時，如果channel已經關閉，則會正常遍歷資料，遍歷完後，就會退出遍歷
    close(intChan2)
    for v := range intChan2 {
        fmt.Println("v=", v)
    }

}

五、 goroutine和channel結合案例

package utils

import (
    "fmt"
)

/*goroutine和channel結合
請完成goroutine和channel協同工作的案例，具體要求：
開啟一個writeData協程，向管道intChan中寫入50個整數.
開啟一個readData協程，從管道intChan中讀取writeData寫入的資料。
注意: writeData和readDate操作的是同一個管道
主執行緒需要等待writeData和readDate協程都完成工作才能退出【管道】


*/
func writeData(intChan chan int) {
    for i := 1; i <= 50; i++ {
        //放入資料
        intChan<- i
        fmt.Println("writeData ", i)
        //time.Sleep(time.Second)
    }
    close(intChan) //關閉
}

//read data
func readData(intChan chan int, exitChan chan bool) {

    for {
        v, ok := <-intChan
        if !ok {
            break
        }
        //time.Sleep(time.Second)
        fmt.Printf("readData 讀到資料=%v\n", v) 
    }
    //readData 讀取完資料後，即任務完成
    exitChan<- true
    close(exitChan)

}

func Test() {

    //建立兩個管道
    intChan := make(chan int, 50)
    exitChan := make(chan bool, 1)

    go writeData(intChan)
    go readData(intChan, exitChan)

    //time.Sleep(time.Second * 10)
    for {
        _, ok := <-exitChan
        if !ok {
            break
        }
    }

}

六、 channel使用細節和注意事項

1、channel可以宣告為只讀，或者只寫性質 【案例演示】
這裡寫圖片描述
2、channel只讀和只寫的最佳實踐案例
這裡寫圖片描述
3、使用select可以解決從管道取資料的阻塞問題【案例演示】

package utils

// 使用select可以解決從管道取資料的阻塞問題

import (
    "fmt"
    "time"
)

func SelectDemo() {

    //使用select可以解決從管道取資料的阻塞問題

    //1.定義一個管道 10個數據int
    intChan := make(chan int, 10)
    for i := 0; i < 10; i++ {
        intChan<- i
    }
    //2.定義一個管道 5個數據string
    stringChan := make(chan string, 5)
    for i := 0; i < 5; i++ {
        stringChan <- "hello" + fmt.Sprintf("%d", i)
    }

    //傳統的方法在遍歷管道時，如果不關閉會阻塞而導致 deadlock

    //問題，在實際開發中，可能我們不好確定什麼關閉該管道.
    //可以使用select 方式可以解決
    //label:
    for {
        select {
            //注意: 這裡，如果intChan一直沒有關閉，不會一直阻塞而deadlock
            //，會自動到下一個case匹配
            case v := <-intChan : 
                fmt.Printf("從intChan讀取的資料%d\n", v)
                time.Sleep(time.Second)
            case v := <-stringChan :
                fmt.Printf("從stringChan讀取的資料%s\n", v)
                time.Sleep(time.Second)
            default :
                fmt.Printf("都取不到了，不玩了, 程式設計師可以加入邏輯\n")
                time.Sleep(time.Second)
                return 
                //break label
        }
    }
}

4、goroutine中使用recover，解決協程中出現panic，導致程式崩潰問題.【案例演示】

說明: 如果我們起了一個協程，但是這個協程出現了panic, 如果我們沒有捕獲這個panic,就會造成整個程式崩潰，這時我們可以在goroutine中使用recover來捕獲panic, 進行處理，這樣即使這個協程發生的問題，但是主執行緒仍然不受影響，可以繼續執行。

package utils

import (
    "fmt"
    "time"
)

//函式
func sayHello() {
    for i := 0; i < 10; i++ {
        time.Sleep(time.Second)
        fmt.Println("hello,world")
    }
}
//函式
func testRecover() {
    //這裡我們可以使用defer + recover
    defer func() {
        //捕獲test丟擲的panic
        if err := recover(); err != nil {
            fmt.Println("test() 發生錯誤", err)
        }
    }()
    //定義了一個map
    var myMap map[int]string
    myMap[0] = "golang" //error
}

func RecoverDemo() {

    go sayHello()
    go testRecover()


    for i := 0; i < 10; i++ {
        fmt.Println("main() ok=", i)
        time.Sleep(time.Second)
    }

}

相關推薦

GO語言之channel

前言： 初識go語言不到半年，我是一次偶然的機會認識了golang這門語言，看到他簡潔的語法風格和強大的語言特性，瞬間有了學習他的興趣。我是很看好go這樣的語言的，一方面因為他有谷歌主推，另一方面他確實有用武之地，高併發就是他的長處。現在的國內完全使用go開發的專案還不是很多，從這個上面

深度解密Go語言之channel

目錄 併發模型 併發與並行 什麼是 CSP 什麼是 channel channel 實現 CSP 為什麼要 channel

GO語言使用之channel(管道)

一、為什麼需要channel 1、需求： 現在要計算 1-200 的各個數的階乘，並且把各個數的階乘放入到map中。最後顯示出來。要求使用goroutine完成 1)、分析思路： 使用goroutine 來完成，效率高，但是會出現併發/並行安全問題. 這裡就提出了不同go

go語言之行--golang核武器goroutine調度原理、channel詳解

-s 丟失 一半 內核調度 保留 dea 等等 ado 線程 一、goroutine簡介 goroutine是go語言中最為NB的設計，也是其魅力所在，goroutine的本質是協程，是實現並行計算的核心。goroutine使用方式非常的簡單，只需使用go關鍵字即可啟動一

go語言之併發程式設計 channel

前面介紹了goroutine的用法，如果有多個goroutine的話相互之間是如何傳遞資料和通訊的呢。在C語言或者JAVA中，傳輸的方法包括共享記憶體，管道，訊號。而在Go語言中，有了更方便的方法，就是channel。在同一時刻，僅有一個goroutine能向一個通道傳送元素值，同時也僅有一個goroutin

Go語言之嵌入類型

go 類型 嵌入類型，或者嵌套類型，這是一種可以把已有的類型聲明在新的類型裏的一種方式，這種功能對代碼復用非常重要。在其他語言中，有繼承可以做同樣的事情，但是在Go語言中，沒有繼承的概念。Go提倡的代碼復用的方式是組合，所以這也是嵌入類型的意義所在。組合而不是繼承，所以Go才會更靈活。type Rea

Go語言之標誌符可見性

goGo的標誌符，這個翻譯覺得怪怪的，不過還是按這個起了標題，可以理解為Go的變量、類型、字段等。這裏的可見性，也就是說那些方法、函數、類型或者變量字段的可見性。比如哪些方法不想讓另外一個包訪問，我們就可以把它們聲明為非公開的；如果需要被另外一個包訪問，就可以聲明為公開的，和Java語言裏的作用域類似。在Go

Go語言之Doc 文檔

go doc 對於協作開發或者代碼共享來說，文檔是一個可以幫助開發者快速了解以及使用這些代碼的一個教程，文檔越全面、越詳細，入門越快，效率也會更高。在Go語言中，Go為我們提供了快速生成文檔以及查看文檔的工具，讓我們可以很容易地編寫查看文檔。Go提供了兩種查看文檔的方式：一種是使用go doc命令在終

Go語言之並發資源競爭

go 並發 並發本身並不復雜，但是因為有了資源競爭的問題，就使得我們開發出好的並發程序變得復雜起來，因為會引起很多莫名其妙的問題。package main import ( "fmt" "runtime" "sync" ) var ( count int32

Go語言之並發示例-Pool(一)

go pool 並發 這篇文章演示使用有緩沖的通道實現一個資源池，這個資源池可以管理在任意多個goroutine之間共享的資源，比如網絡連接、數據庫連接等，我們在數據庫操作的時候，比較常見的就是數據連接池，也可以基於我們實現的資源池來實現。可以看出，資源池也是一種非常流暢性的模式，這種模式一般適用

Go語言之log日誌

log go 在我們開發程序後，如果有一些問題需要對程序進行調試的時候，日誌是必不可少的，這是我們分析程序問題常用的手段。 日誌使用 日誌分析，就是根據輸出的日誌信息，分析挖掘可能的問題，我們使用fmt.Println系列函數也可以達到目的，因為它們也可以把我們需要的信息輸出到終端或者其他文件中。不過

go語言之指針

ptr數組 Arrays數組是內置(build-in)類型,是一組同類型數據的集合，它是值類型，通過從0開始的下標索引訪問元素值。在初始化後長度是固定的，無法修改其長度。當作為方法的入參傳入時將復制一份數組而不是引用同一指針。數組的長度也是其類型的一部分，通過內置函數len(array)獲取其長度。在開始前先

Go語言之調試

調試 go 調試是一種技能，不限於我們說的debug，這只是其中的一種，這是可以打斷點的調試，除此之外，還有打印輸出、日誌記錄、單元測試，這都可以稱之為調試程序的手段。打印輸出打印輸出是一種比較傳統的調試手段，我們可以把我們需要了解的變量值，執行的步驟等打印出來，來證明我們的猜測，以便解決問題。fun

Go語言之數據類型總結

go語言 數據 數據類型字符串：字符串是不可變的字節序列，本身就是一個復合結構。頭部指針指向字節數組，但是沒有NULL結尾。默認以UTF-8編碼存儲Unicode字符，字面量裏允許使用十六進制、八進制和UTF-8編碼格式。內置函數len返回字節數組長度，cap不接受字符串類型參數。字符串默認是nil而不是&

Go語言之方法詳解

go語言 方法方法是與對象實例綁定的特殊函數。用於維護和展示對象自身的狀態。對象是內斂的。普通函數則專註與算法流程，通過接受參數來完成特定的邏輯運算，並返回最終結果，方法是有關聯狀態的，函數通常是沒有的。方法和函數定義語法區別在於前者實例接受參數，編譯器以此確定方法所屬的類型。在一些語言中盡管沒有定義，但是函

Go語言之項目的包結構詳解

go語言 包結構Go語言的工作空間：通常添加到GOPATH中。 src bin pkg對於bin和pkg兩個目錄，主要影響go install/get命令，它們會將編譯結果安裝到這兩個目錄下，以實現增量編譯。環境變量用於實現GOPATH只是工具鏈和標準庫的存放位置。在使用Git等版本控制工具的時候，建議忽略

Go語言之常量與運算符

常量 運算符 用例1 //此文件用來練習 //常量與運算符的 package main import "fmt" //定義單個常量 const SPARK_NAME = "spark-test001" const NODE_NUM int = 3 //下面的方式，只是簡寫 const (

Go語言之切片Slice練習

切片slice切片Slice理論知識 其本身並不是數組，它指向底層的數組 作為編程數組的替代方案，可以關聯底層數組的局部或者全部 為引用類型 可以直接創建或從底層數組獲取生成 使用len()獲取元素個數，cap()獲取容量 一般使用make()創建 如果多個slice指向相同底層數組，其中一個的值改變會影響

Go語言之map練習

mapmap理論基礎知識 類似其他語言中的哈希表或者字典，以key-value形式存儲數據 key必須是支持== 或者 != 比較運算的類型，不可以是函數，map或者slice map查找比線性搜索快很多，但比使用索引訪問數據的類型慢100倍 map使用make()創建，支持:=這種簡寫方式 make(

Go語言之method

method方法method Go 中雖沒有class, 但依舊有method 通過顯示說明receiver來實現與某個類型的組合 只能為同一個包中的類型定義方法 receiver可以是類型的值或指針 不存在方法重載 可以使用值或者指針來調用方法，編譯器會自動完成轉換 從某種意義上來說，方法是函數的語法糖，