Golang-goroutine/channel

goroutine-基本介紹

進程和線程介紹

　　　　

 

 

程序、進程和線程的關係示意圖

　　　　

併發和並行

　　1)多線程程序在單核上運行，就是併發
　　2)多線程程序在多核上運行，就是並行
　　3)示意圖:

　　　　 

　　　　小結：

　　　　

 

 

 

Go 協程和Go 主線程

　　　　Go 主線程(有程序員直接稱爲線程/也能夠理解成進程): 一個 Go 線程上，能夠起多個協程，你能夠這樣理解，協程是輕量級的線程[編譯器作優化]。

Go 協程的特色
　　　　1)有獨立的棧空間
　　　　2)共享程序堆空間
　　　　3)調度由用戶控制
　　　　4)協程是輕量級的線程

　　　　示意圖

　　　　　　

 

 

 　　

goroutine-快速入門
　　　案例說明
　　　　請編寫一個程序，完成以下功能:
　　　　1)在主線程(能夠理解成進程)中，開啓一個 goroutine, 該協程每隔 1 秒輸出 "hello,world"
　　　　2)在主線程中也每隔一秒輸出"hello,golang", 輸出 10 次後，退出程序
　　　　3)要求主線程和 goroutine 同時執行.
　　　　4)畫出主線程和協程執行流程圖

　　　　

 

 

 　　　　輸出的效果說明， main 這個主線程和 test 協程同時執行.

　　　　

 

 

主線程和協程執行流程圖

　　

 

 

 

快速入門小結
　　1)主線程是一個物理線程，直接做用在 cpu 上的。是重量級的，很是耗費 cpu 資源。
　　2)協程從主線程開啓的，是輕量級的線程，是邏輯態。對資源消耗相對小。
　　3)Golang 的協程機制是重要的特色，能夠輕鬆的開啓上萬個協程。其它編程語言的併發機制是通常基於線程的，開啓過多的線程，資源耗費大，這裏就突顯 Golang 在併發上的優點了

goroutine 的調度模型
　　MPG 模式基本介紹

　　

 

 　　MPG 模式運行的狀態 1

　　

 

 　　MPG 模式運行的狀態 2

　　

 　　

設置 Golang 運行的cpu 數
　　介紹：爲了充分了利用多 cpu 的優點，在 Golang 程序中，設置運行的 cpu 數目

　　

 

 

 　　

　　channel(管道)-看個需求
　　　　需求：如今要計算 1-200 的各個數的階乘，而且把各個數的階乘放入到 map 中。最後顯示出來。要求使用 goroutine 完成

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

　　代碼實現
　　　　1)使用 goroutine 來完成(看看使用 gorotine 併發完成會出現什麼問題? 而後咱們會去解決)
　　　　2)在運行某個程序時，如何知道是否存在資源競爭問題。 方法很簡單，在編譯該程序時，增長一個參數 -race 便可 [示意圖]

package main 
import (
	"fmt"
	"time"
)
	
	// 需求：如今要計算 1-200 的各個數的階乘，而且把各個數的階乘放入到 map 中。
	// 最後顯示出來。要求使用 goroutine 完成
	
	// 思 路
	// 1. 編寫一個函數，來計算各個數的階乘，並放入到 map 中.
	// 2. 咱們啓動的協程多個，統計的將結果放入到 map 中
	// 3. map  應該作出一個全局的.

var (
	myMap = make(map[int]int, 10)
	)
	
	// test 函數就是計算 n!, 讓將這個結果放入到 myMap 
func test(n int) {
	
	res := 1
	for i := 1; i <= n; i++ {
		 res *= i
	}
	
	//這裏咱們將 res 放入到 myMap
	myMap[n] = res //concurrent map writes?
}
func main() {

	// 咱們這裏開啓多個協程完成這個任務[200 個] 
	for i := 1; i <= 200; i++ {
		go test(i)
	}
	//休眠 10 秒鐘【第二個問題 】
	time.Sleep(time.Second * 10)

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

}

　　示意圖

　

 

 

 

不一樣goroutine 之間如何通信

　　1)全局變量的互斥鎖

　　

　　2)使用管道 channel 來解決

　　使用全局變量加鎖同步改進程序

　　由於沒有對全局變量 m 加鎖，所以會出現資源爭奪問題，代碼會出現錯誤，提示 concurrent map writes

解決方案：加入互斥鎖

　　咱們的數的階乘很大，結果會越界,能夠將求階乘改爲 sum += uint64(i)

代碼改進

 

 

 

 爲何須要channel

　　1)前面使用全局變量加鎖同步來解決 goroutine 的通信，但不完美

　　2)主線程在等待全部 goroutine 所有完成的時間很難肯定，咱們這裏設置 10 秒，僅僅是估算。

　　3)若是主線程休眠時間長了，會加長等待時間，若是等待時間短了，可能還有 goroutine 處於工做狀態，這時也會隨主線程的退出而銷燬

　　4)經過全局變量加鎖同步來實現通信，也並不利用多個協程對全局變量的讀寫操做。

　　5)上面種種分析都在呼喚一個新的通信機制-channel

channel 的基本介紹

　　1)channle 本質就是一個數據結構-隊列【示意圖】

　　2)數據是先進先出【FIFO : first in first out】

　　3)線程安全，多 goroutine 訪問時，不須要加鎖，就是說 channel 自己就是線程安全的

　　4)channel 有類型的，一個 string 的 channel 只能存放 string 類型數據。

　　5)示意圖：

 　　

 

定義/聲明 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 main 
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 使用的注意事項

　　1)channel 中只能存放指定的數據類型

　　2)channle 的數據放滿後，就不能再放入了

　　3)若是從 channel 取出數據後，能夠繼續放入

　　4)在沒有使用協程的狀況下，若是 channel 數據取完了，再取，就會報 dead lock

 

　　 讀寫channel 案例演示

　　　　

 

 　　　　

 

 　　　　

 

 　　　　

 

 　　　　

 

 　　　　 

 

管道的練習題

　　

 

channel 的遍歷和關閉

 

　　channel 的關閉

　　　　使用內置函數close 能夠關閉 channel, 當 channel 關閉後，就不能再向 channel 寫數據了，可是仍然能夠從該 channel 讀取數據

　　案例演示：

 　　　　

 

 

　　channel 的遍歷

　　channel 支持 for--range 的方式進行遍歷，請注意兩個細節

　　1)在遍歷時，若是 channel 沒有關閉，則回出現 deadlock 的錯誤

　　2)在遍歷時，若是 channel 已經關閉，則會正常遍歷數據，遍歷完後，就會退出遍歷。

　　channel 遍歷和關閉的案例演示

　　看代碼演示：

　　　　

 

 　　應用實例

　　　　

 

 　　思路分析

　　　　

 

 　　代碼實現

　　　　

package main 
import (
	"fmt"
	_ "time"
)
	
//write Data
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 main() {

	//建立兩個管道
	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
		}
	}
}
	

　　

應用實例 2-阻塞

　　

 

 應用實例 3

　　需求：

　　要求統計 1-200000 的數字中，哪些是素數？這個問題在本章開篇就提出了，如今咱們有 goroutine和 channel 的知識後，就能夠完成了 [測試數據: 80000]

 

　　分析思路：

　　傳統的方法，就是使用一個循環，循環的判斷各個數是否是素數【ok】。

　　使用併發/並行的方式，將統計素數的任務分配給多個(4 個)goroutine 去完成，完成任務時間短。

　　畫出分析思路

　　　　

 

 　　代碼實現

　　　　

package main import (
	"fmt"
	"time"
	
	)
	
//向 intChan 放入 1-8000 個數
func putNum(intChan chan int) {
	
	for i := 1; i <= 8000; i++ { 
		intChan<- i
	}
	
	//關閉 intChan
	close(intChan)
}
	
	
// 從 intChan 取出數據，並判斷是否爲素數,若是是，就
//	//放入到 primeChan
func primeNum(intChan chan int, primeChan chan int, exitChan chan bool) {
	
	//使用 for 循環
	var flag bool 
	for {
		time.Sleep(time.Millisecond * 10) 
		num, ok := <-intChan
		
		if !ok { //intChan 取不到.. 
			break
		}
		flag = true //假設是素數
		//判斷 num 是否是素數
		for i := 2; i < num; i++ {
			if num % i == 0 {//說明該 num 不是素數
				flag = false break
			}
		}
		
		if flag {
			//將這個數就放入到 primeChan 
			primeChan<- num
		}
	}
		
	fmt.Println("有一個 primeNum  協程由於取不到數據，退出")
	//這裏咱們還不能關閉 primeChan
	//向 exitChan  寫入 true
	exitChan<- true
}

func main() {

	intChan := make(chan int , 1000)
	primeChan := make(chan int, 2000)//放入結果
	//標識退出的管道
	exitChan := make(chan bool, 4) // 4 個
	
	//開啓一個協程，向 intChan 放入 1-8000 個數
	go putNum(intChan)
	//開啓 4 個協程，從 intChan 取出數據，並判斷是否爲素數,若是是，就
	//放入到 primeChan
	for i := 0; i < 4; i++ {
		go primeNum(intChan, primeChan, exitChan)
	
	}
	
	//這裏咱們主線程，進行處理
	//直接
	go func(){
		for i := 0; i < 4; i++ {
			<-exitChan
		}
		//當咱們從 exitChan 取出了 4 個結果，就能夠放心的關閉 prprimeChan 
		close(primeChan)
	}()

	//遍歷咱們的 primeChan ,把結果取出
	for {
		res, ok := <-primeChan 
		if !ok{
			break
		}
		//將結果輸出
		fmt.Printf("素數=%d\n", res)
	}
	
	fmt.Println("main 線程退出")
}

 

結論：使用 go 協程後，執行的速度，比普通方法提升至少 4 倍

 

channel 使用細節和注意事項

　　1)channel 能夠聲明爲只讀，或者只寫性質 【案例演示】

　　　　

　　

　　2)channel 只讀和只寫的最佳實踐案例

　　　　

　　

　　3)使用 select 能夠解決從管道取數據的阻塞問題

package main 
import (
	"fmt"
	"time"
)
	
func main() {
	
	//使用 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，致使程序崩潰問題

 

　　　　

 

 

package main 
import (
	"fmt"
	"time"
)

//函數
func sayHello() {
	for i := 0; i < 10; i++ { 
		time.Sleep(time.Second) 
		fmt.Println("hello,world")
	}
}
//函數
func test() {
	//這裏咱們可使用 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 main() {

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