2. 程式人生 > >GO語言學習（四）---chan

GO語言學習（四）---chan

阿新 • • 發佈：2018-12-22

chan相關知識

程式碼片段一—chan用於兩個goruntime之間通訊

原始碼

//測試chan
package main

import "fmt"
import "time"

var strChan = make(chan string,3)

func main(){
    syncChan1 := make(chan struct{},1)  //接收同步變數  
    syncChan2 := make(chan struct{},2) //主執行緒啟動了兩個goruntime執行緒，
                                       //等這兩個goruntime執行緒結束後主執行緒才能結束
 


    //用於演示接受操作
    go func(){
        <- syncChan1  //表示可以開始接收資料了，否則等待
        fmt.Println("[receiver] Received a sync signal and wait a second...")
        time.Sleep(time.Second)
        for{
            if elem,ok := <-strChan;ok{
                fmt.Println("[receiver] Received:",elem)
            }else
 
{
                break
            }
        }
        fmt.Println("[receiver] Stopped.")
        syncChan2 <- struct{}{}
    }()

    //用於演示傳送操作
    go func(){
        for i,elem := range []string{"a","b","c","d"}{
            fmt.Println("[sender] Sent:",elem)
            strChan <- elem
            if
 
 (i+1)%3==0 {
                syncChan1 <- struct{}{}
                fmt.Println("[sender] Sent a sync signal. wait 1 secnd...")
                time.Sleep(time.Second)
            }
        }
        fmt.Println("[sender] wait 2 seconds...")
        time.Sleep(time.Second)
        close(strChan)
        syncChan2 <- struct{}{}
    }()

    //主執行緒等待發送執行緒和接收執行緒結束後再結束
    fmt.Println("[main] waiting...")
    <- syncChan2
    <- syncChan2
    fmt.Println("[main] stoped")
}

執行結果

[main] waiting...
[sender] Sent: a
[sender] Sent: b
[sender] Sent: c
[sender] Sent a sync signal. wait 1 secnd...
[receiver] Received a sync signal and wait a second...
[receiver] Received: a
[receiver] Received: b
[receiver] Received: c
[sender] Sent: d
[sender] wait 2 seconds...
[receiver] Received: d
[receiver] Stopped.
[main] stoped

相關知識點

  • struch{}代表不包含任何欄位的結構體型別，也可稱為空結構體型別。在go語言中，空結構體型別是不佔用系統記憶體的，並且所有該型別的變數都擁有相同的記憶體地址。建議用於傳遞訊號的通道都以struct{}作為元素型別，除非需要傳遞更多的資訊
  • 傳送方向通道傳送的值會被複制，接收方接收到的總是該值得副本，而不是該值本身。經由通道傳遞的值最少會被複制一次，最多會被複制兩次。例如，當向一個已空的通道傳送值，且已有至少一個接收方因此等待時，該通道會繞過本身的緩衝佇列，直接把這個值複製給最早等待的那個接收方，這種情況傳遞的值只複製一次；當從一個已滿的通道接收值，且已有至少一個傳送方因此等待時，該通道會把緩衝佇列中最早進入的那個值複製給接收方，再把最早等待的傳送方要傳送的資料複製到那個值得原先位置上（通道的緩衝佇列屬於環形佇列，這樣做是沒有問題的），這種情況傳遞的值複製兩次。
  • 通道傳遞是複製傳遞的值。因此如果傳遞的是值型別，接收方對該值得修改不會影響傳送方持有的值；如果傳遞的是引用型別，則傳送方或者接收方對該物件的修改會影響雙方所持有的物件

程式碼片段二—chan引用傳遞

原始碼

package main

import(
    "fmt"
    "time"
)

var mapChan =  make(chan map[string]int,1)

func main(){
    syncChan := make(chan struct{},2)

    //用於演示接收操作
    go func(){
        for{
            if elem,ok:= <- mapChan;ok{
                elem["count"]++   //每次接收到chan裡面的map物件後，將key為count的值加1
            }else{
                break
            }
        }
        fmt.Println("[receiveder] stoped.")
        syncChan <- struct{}{}
    }()

    //用於演示傳送操作
    go func(){
        countMap := make(map[string]int)
        for i:=0;i<5;i++{
            mapChan <- countMap
            time.Sleep(time.Second)
            fmt.Println("[sender] the count map:",countMap)
        }
        fmt.Println("[sender] stop chan.")
        close(mapChan)
        fmt.Println("[sender] stoped.")
        syncChan <- struct{}{}
    }()
    fmt.Println("[main] waiting...")
    <- syncChan
    <- syncChan
    fmt.Println("[main] stoped.")
}

執行結果

[main] waiting...
[sender] the count map: map[count:1]
[sender] the count map: map[count:2]
[sender] the count map: map[count:3]
[sender] the count map: map[count:4]
[sender] the count map: map[count:5]
[sender] stop chan.
[sender] stoped.
[receiveder] stoped.
[main] stoped.

相關知識點

  • 上述程式碼通道中傳遞的是map型別，屬於引用型別，因此接收方對元素值得修改會影響到傳送方持有的值
  • 呼叫close可以關閉通道。注意：師徒向一個已經關閉的通道傳送元素值，會讓傳送操作引發執行時恐慌。因此一定要在確保安全的前提下關閉通道。
  • 無論怎麼樣都不應該在接收端關閉通道。因為在接收端通常無法判斷髮送端是否還會向該通道傳送元素值。
  • 在傳送端關閉通道不會對接收端的接收操作產生什麼影響。如果通道在被關閉時其中仍有元素值，接收端仍然可以接收，病根據接收表示式的第二個結果值判斷通道是否關閉或者是否有元素可取
  • 內建函式len和cap可用於通道之上。len表示獲取通道中當前元素的數量，cap表示獲取通道的容量。通道的長度隨著通道中擁有的元素數量而變化，而通道的容量是在初始化的時候確定的，之後不會再修改

程式碼片段三—單向通道

原始碼

package main

import "fmt"
import "time"

var strChan = make(chan string,3)

func main(){
    synChan1 := make(chan struct{},1)
    synChan2 := make(chan struct{},2)

    go receiver(strChan,synChan1,synChan2)  
    go sender(strChan,synChan1,synChan2)

    fmt.Println("[main] waiting...")
    <- synChan2
    <- synChan2
    fmt.Println("[main] stoped.")
}

//用於演示接收
func receiver(strChan <-chan string,synChan1 <-chan struct{},synChan2 chan<- struct{}){
    <-synChan1
    fmt.Println("[receiver] Received a sync signal and wait a second...")
    time.Sleep(time.Second)
    for{
        if elem,ok := <-strChan;ok{
            fmt.Println("[receiver] Received:",elem)
        }else{
            break
        }
    }
    synChan2 <- struct{}{}
}

//用於演示傳送
func sender(strChan chan<- string,synChan1 chan<- struct{},synChan2 chan<- struct{}){
    for _,elem := range []string{"a","b","c","d"}{
        fmt.Println("{sender} sent:",elem)
        strChan <- elem
        if elem=="c"{
            fmt.Println("[sender] Sent a sync signal.")
            synChan1 <- struct{}{}
        }
    }
    fmt.Println("wait 2 seconds....")
    time.Sleep(time.Second*2)
    close(strChan)
    synChan2 <- struct{}{}
}

執行結果

[main] waiting...
[sender] sent: a
[sender] sent: b
[sender] sent: c
[sender] Sent a sync signal.
[sender] sent: d
[receiver] Received a sync signal and wait a second...
[receiver] Received: a
[receiver] Received: b
[receiver] Received: c
[receiver] Received: d
[sender] wait 2 seconds....
[main] stoped.

相關知識點

  • 單向通道分為傳送通道和接收通道。需要注意的是，無論哪種單向通道，都不應該出現在變數的宣告中，否則沒有意義。單向通道一般都是用在函式引數中，它由雙向通道變換而來，表示該函式作用域內，只能對該通道進行傳送或者接收操作。
  • 在介面或者函式引數中定義單向通道，也可以在返回值中定義單向通道。函式或者方法的返回值為單向通道可以約束呼叫該函式或者方法的結果值的使用方式】

程式碼片段四—for語句與channel

原始碼

package main

import "fmt"
import "time"

var strChan = make(chan string,1)

func main(){
    synChan2 := make(chan struct{},2)

    go receiver(strChan,synChan2)  
    go sender(strChan,synChan2)

    fmt.Println("[main] waiting...")
    <- synChan2
    <- synChan2
    fmt.Println("[main] stoped.")
}

//用於演示接收
func receiver(strChan <-chan string,synChan2 chan<- struct{}){
    for elem := range strChan{
        fmt.Println("[receiver] Received:",elem)
        time.Sleep(time.Second*2)
    }
    synChan2 <- struct{}{}
}

//用於演示傳送
func sender(strChan chan<- string,synChan2 chan<- struct{}){
    for _,elem := range []string{"a","b","c","d"}{
        fmt.Println("[sender] sent:",elem)
        strChan <- elem
        time.Sleep(time.Second*1)
    }
    close(strChan)
    synChan2 <- struct{}{}
}

執行結果

[main] waiting...
[sender] sent: a
[receiver] Received: a
[sender] sent: b
[sender] sent: c
[receiver] Received: b
[sender] sent: d
[receiver] Received: c
[receiver] Received: d
[main] stoped.

相關知識點

  • 當定義chan大小為1時，容量為1，表示緩衝大小為1；當定義chan大小為0時，容量為0，表示該通道沒有緩衝區，傳送方傳送一個值後需要等待接收方接收才可以傳送下一個值
  • for語句中可以使用range子句從通道中持續不斷地接收資料。當通道還未被初始化或者通道中沒有任何元素時，for語句所在的goruntime會陷入阻塞，阻塞的具體位置在其中的range子句處。for語句會不斷地嘗試從通道中接收元素，直到該通道關閉

程式碼片段五—select語句與channel

原始碼

package main

import "fmt"

var intChan1 chan int 
var intChan2 chan int
var numbers = []int{1,2,3,4,5}

func main(){
    intChan1 = make(chan int,1)
    intChan2 = make(chan int,1)
    select{
        case intChan1<-numbers[0]: fmt.Println("1th case is selected.")
        case intChan2<-numbers[1]: fmt.Println("2th case is selected.")
        default: fmt.Println("default is selected.")
    }
}

執行結果

1th case is selected.

或者

2th case is selected.

相關知識點

  • select語句是一種僅能用於通道傳送和接收操作的專用語句。
  • 在開始執行select語句的時候，所有跟在case關鍵字右邊的傳送語句或者接收語句中的通道表示式和元素表示式都會先求值（求值的順序是從左到右、從上到下），無論它們所在的case是否有可能被選中都是會執行
  • 在執行select語句的時候，執行時系統會自上而下地判斷每個case中的傳送或接收操作是否可以立即執行。這裡的立即執行指的是當前goruntime不會因此操作而被阻塞。只要發現有一個case上的判斷是肯定的，則該case就會被選中；如果有多個case被選中，則系統會通過一個偽隨機演算法選中一個case；如果都沒有選中則執行default語句；如果沒有default語句，則當前goruntime會在select語句處阻塞，直到至少有一個case中的傳送或者接收操作可以立即執行為止
  • select語句中的case以及default語句之間位置沒有前後

相關推薦

GO語言學習（四）---chan

chan相關知識 程式碼片段一—chan用於兩個goruntime之間通訊 原始碼 //測試chan package main import "fmt" import "time"

C語言學習（四）

vc++ gin margin 結果 com 語言學 http std oid 面試題中二進制轉換問題，將一個二進制數，從某位開始進行，n位轉換，程序如下所示： 1 /***************************************************

Go語言開發（四）、Go語言面向對象

name value code 對象 struct int() 初始 每一個 method Go語言開發（四）、Go語言面向對象 一、結構體和方法 1、結構體的定義 在結構體中可以為不同項定義不同的數據類型。結構體是由一系列具有相同類型或不同類型的數據構成的數據集合。結構體

C++語言學習（四）——類與對象

clas 進行 自身 ngs 符號表 方法 index clu 每一個 C++語言學習（四）——類與對象 一、構造函數（constructor） 1、構造函數簡介 C++語言中，構造函數是與類名相同的特殊成員函數。在類對象創建時，自動調用構造函數，完成類對象的初始化。類對象

GO語言學習（三）GO語言學習API文檔

tro 文檔 lan get study spa Go語言 tps http 一：GoLang標準庫API文檔 https://studygolang.com/pkgdoc GO語言學習（三）GO語言學習API文檔

GO語言學習（五）Go 語言基礎語法

序列 單行 break ani 開頭 ntp false nil div Go 標記 Go 程序可以由多個標記組成，可以是關鍵字，標識符，常量，字符串，符號。如以下 GO 語句由 6 個標記組成： fmt.Println("Hello, World!")

GO語言學習（六）Go 語言數據類型

支持 Go語言 基於 固定 run 出現 簡單 架構 ble 在 Go 編程語言中，數據類型用於聲明函數和變量。 數據類型的出現是為了把數據分成所需內存大小不同的數據，編程的時候需要用大數據的時候才需要申請大內存，就可以充分利用內存。 Go 語言按類別有以下幾種數據類

GO語言學習（七）Go 語言變量

數據 指定 需要 內容 load 默認值 操作符 此外 alt Go 語言變量 變量來源於數學，是計算機語言中能儲存計算結果或能表示值抽象概念。變量可以通過變量名訪問。 Go 語言變量名由字母、數字、下劃線組成，其中首個字母不能為數字。 聲明變量的一般形式是使用 va

DTL語言學習（四）{% spaceless %}、{% autospace %}和{% verbatim %}標籤

{% spaceless %}標籤 移除html標籤中的空白字元，包括空格，換行鍵，tab鍵等。 首先建立一個測試環境，相信看到看到這裡的都知道怎樣建立一個測試環境了。這裡就不細說了。 我們在html中寫入一下程式碼： <div> <p>

go語言學習（一）

上網過程：  　　             對於普通的上網過程，系統其實是這樣做的：瀏覽器本身是一個客戶端，當你輸入URL的時候，首先瀏覽器會去請求DNS伺服器，通過DNS獲取相應的域名對應的IP，然後通過IP地址找到IP對應的

Go語言學習（三） 簡單比特幣挖礦類實現

//utils.go package main import ( "bytes" "encoding/binary" "log" ) func IntToHex(num int64)[]byte{ buff:=new(bytes.Buffer) //開闢記憶體，

R語言學習（四）——泊松分佈

dpois(x, lambda, log = FALSE) ppois(q, lambda, lower.tail = TRUE, log.p = FALSE) qpois(p, lambda, lower.tail = TRUE, log.p = FALSE)

go語言學習（3）面向物件,結構體和方法

感覺每種語言都是其他的語言的一些交集,看見go就有種kotlin和C的孩子的感覺,雖然我並不清楚他們之間的借鑑關係 go語言僅支援封裝,不支援繼承和多型 go語言只有struct沒有class go語言的結構的定義和C++類似 type treeNode struct

C語言學習（四）shell指令碼

       Linux系統中的Shell種類眾多，常見的有bash、csh以及ksh等。不同的Shell語法有所不同，不能互換使用，但每種Shell都有其特色之處。這裡我們選擇bash來講述Shell指令碼程式設計的基礎知識。Shell命令可以事先寫在一個檔案中，使用時Sh

go語言學習（3）-協程

現在主流os呼叫粒度為執行緒，產生時鐘中斷後，中斷處理函式，如果當前執行緒時間片使用完畢。則切換到其他的執行緒，資源開銷很大。還有建立和銷燬執行緒是和很消耗執行緒資源的。特別是對於我們後臺程式開發，為了減少不必要的效能開銷，廣泛採用"池"進行維護。 於是乎協程出現了，協程可

C語言學習（四）在學習C語言時遇到的一些細節方面的問題

strlen與sizeof的區別：  strlen用來求字串的長度用的（不算最後的NULL）而sizeof是用來求指定變數或者變數型別等所佔記憶體大小用的比如strlen（"nihao"）它的結果是5而sizeof(int)它的結果是4也就是說int型佔四個位元組。它與是不是

GO語言學習（十四）Go 語言數組

brush 多維數組 type 本質 數據結構 com 循環 方式 整型 Go 語言數組 Go 語言提供了數組類型的數據結構。 數組是具有相同唯一類型的一組已編號且長度固定的數據項序列，這種類型可以是任意的原始類型例如整形、字符串或者自定義類型。 相對於去聲明numb

GO語言學習（十五）Go 語言指針

%x pre ble 內存地址 內容 none oat enc 空值 Go 語言指針 Go 語言中指針是很容易學習的，Go 語言中使用指針可以更簡單的執行一些任務。 接下來讓我們來一步步學習 Go 語言指針。 我們都知道，變量是一種使用方便的占位符，用於引用計算機內存

GO語言學習（十八）Go 語言接口

結構 數據 ble 語言 print 一起 實例 ... class Go 語言接口 Go 語言提供了另外一種數據類型即接口，它把所有的具有共性的方法定義在一起，任何其他類型只要實現了這些方法就是實現了這個接口。 實例 /* 定義接口 */ type inter

GO語言學習（十九）Go 錯誤處理

錯誤處理 math println 接口 class int 處理機 nil sprintf Go 錯誤處理 Go 語言通過內置的錯誤接口提供了非常簡單的錯誤處理機制。 error類型是一個接口類型，這是它的定義： type error interface {