goroutine-看一個需求
需求：要求統計 1-9000000000 的數字中，哪些是素數？程序員
分析思路：
1) 傳統的方法，就是使用一個循環，循環的判斷各個數是否是素數。[很慢]
2) 使用併發或者並行的方式，將統計素數的任務分配給多個 goroutine 去完成，這時就會使用到goroutine.【速度提升 4 倍】golang
進程和線程介紹編程
程序、進程和線程的關係安全
併發和並行
1) 多線程程序在單核上運行，就是併發
2) 多線程程序在多核上運行，就是並行數據結構
Go 主線程(有程序員直接稱爲線程/也能夠理解成進程): 一個 Go 線程上，能夠起多個協程，你能夠這樣理解，協程是輕量級的線程[編譯器作優化]。多線程
Go 協程的特色
1) 有獨立的棧空間
2) 共享程序堆空間
3) 調度由用戶控制
4) 協程是輕量級的線程併發
案例說明
請編寫一個程序，完成以下功能:
1) 在主線程(能夠理解成進程)中，開啓一個 goroutine, 該協程每隔 1 秒輸出 "hello,world"
2) 在主線程中也每隔一秒輸出"hello,golang", 輸出 10 次後，退出程序
3) 要求主線程和 goroutine 同時執行.編程語言
package main
import (
"fmt"
"strconv"
"time"
)
// 在主線程(能夠理解成進程)中，開啓一個goroutine, 該協程每隔1秒輸出 "hello,world"
// 在主線程中也每隔一秒輸出"hello,golang", 輸出10次後，退出程序
// 要求主線程和goroutine同時執行
//編寫一個函數，每隔1秒輸出 "hello,world"
func test() {
for i := 1; i <= 10; i++ {
fmt.Println("tesst () hello,world " + strconv.Itoa(i))
time.Sleep(time.Second)
}
}
func main() {
go test() // 開啓了一個協程
for i := 1; i <= 10; i++ {
fmt.Println(" main() hello,golang" + strconv.Itoa(i))
time.Sleep(time.Second)
}
}
1) 主線程是一個物理線程，直接做用在 cpu 上的。是重量級的，很是耗費 cpu 資源。
2) 協程從主線程開啓的，是輕量級的線程，是邏輯態。對資源消耗相對小。
3) Golang 的協程機制是重要的特色，能夠輕鬆的 開啓上萬個協程。其它編程語言的併發機制是通常基於線程的，開啓過多的線程，資源耗費大，這裏就突顯 Golang 在併發上的優點了函數
解釋一下MPG含義：
M（Machine）：操做系統的主線程
P（Processor）：協程執行須要的資源（上下文context），能夠看做一個局部的調度器，使go代碼在一個線程上跑，他是實現從N：1到N：M映射的關鍵
G（Gorountine）：協程，有本身的棧。包含指令指針（instruction pointer）和其它信息（正在等待的channel等等），用於調度。一個P下面能夠有多個G測試
P的數量能夠經過GOMAXPROCS()來設置，他其實表明了真正的併發度，即有多少個goroutine能夠同時運行。P同時也維護着G（協程）的隊列（稱之爲runqueue進程隊列）。Go代碼中的M每有一個語句被執行，P就在末尾加入一個G（從runqueue隊列中取出來的），在下一個調度點（P），就從runqueue隊列中取出G。
P能夠在OS線程（主線程，或者是M）被阻塞時，轉到另外一個OS線程（M）！Go中的調度器保證有足夠的線程來運行全部的P。當啓用一個M0中的G0被sysCall（系統調用）的時候，M0下面的P轉給另外一個線程M1（能夠是建立的，也能夠是本來就存在的）。M1接受了P（包括P所帶的runqueue的隊列裏面全部狀態的G，但不包括已經被syscall的G0），繼續運行。而M0會等待執行syscall的G0的返回值。當G0的syscall結束後，他的主線程M0會嘗試取得一個P來運行G0，通常狀況下，他會從其餘的M裏面偷一個P過來，若是沒有偷到的話就會把G0放到一個Global runqueue（全局進程隊列）中，而後把本身（M0）放進線程池或者轉爲休眠狀態。
介紹：爲了充分了利用多 cpu 的優點，在 Golang 程序中，設置運行的 cpu 數目
package main
import (
"runtime"
"fmt"
)
func main() {
cpuNum := runtime.NumCPU()
fmt.Println("cpuNum=", cpuNum)
//能夠本身設置使用多個cpu
runtime.GOMAXPROCS(cpuNum - 1)
fmt.Println("ok")
}
需求：如今要計算 1-200 的各個數的階乘，而且把各個數的階乘放入到 map 中。最後顯示出來。
要求使用 goroutine 完成
分析思路：
1) 使用 goroutine 來完成，效率高，可是會出現併發/並行安全問題.
2) 這裏就提出了不一樣 goroutine 如何通訊的問題
代碼實現
1) 使用 goroutine 來完成(看看使用 gorotine 併發完成會出現什麼問題? 而後去解決)
2) 在運行某個程序時，如何知道是否存在資源競爭問題。 方法很簡單，在編譯該程序時，增長一個參數 -race 便可
1) 全局變量的互斥鎖
2) 使用管道 channel 來解決
由於沒有對全局變量 m 加鎖，所以會出現資源爭奪問題，代碼會出現錯誤，提示 concurrent map
writes
解決方案：加入互斥鎖
咱們的數的階乘很大，結果會越界,能夠將求階乘改爲 sum += uint64(i)
package main
import (
"fmt"
_ "time"
"sync"
)
// 需求：如今要計算 1-200 的各個數的階乘，而且把各個數的階乘放入到map中。
// 最後顯示出來。要求使用goroutine完成
// 思路
// 1. 編寫一個函數，來計算各個數的階乘，並放入到 map中.
// 2. 咱們啓動的協程多個，統計的將結果放入到 map中
// 3. map 應該作出一個全局的.
var (
myMap = make(map[int]int, 10)
//聲明一個全局的互斥鎖
//lock 是一個全局的互斥鎖，
//sync 是包: synchornized 同步
//Mutex : 是互斥
lock sync.Mutex
)
// test 函數就是計算 n!, 讓將這個結果放入到 myMap
func test(n int) {
res := 1
for i := 1; i <= n; i++ {
res *= i
}
//這裏咱們將 res 放入到myMap
//加鎖
lock.Lock()
myMap[n] = res //concurrent map writes?
//解鎖
lock.Unlock()
}
func main() {
// 咱們這裏開啓多個協程完成這個任務[200個]
for i := 1; i <= 20; i++ {
go test(i)
}
//休眠10秒鐘【第二個問題 】
//time.Sleep(time.Second * 5)
//這裏咱們輸出結果,變量這個結果
lock.Lock()
for i, v := range myMap {
fmt.Printf("map[%d]=%d\n", i, v)
}
lock.Unlock()
}
1) 前面使用全局變量加鎖同步來解決 goroutine 的通信，但不完美
2) 主線程在等待全部 goroutine 所有完成的時間很難肯定，咱們這裏設置 10 秒，僅僅是估算。
3) 若是主線程休眠時間長了，會加長等待時間，若是等待時間短了，可能還有 goroutine 處於工做
狀態，這時也會隨主線程的退出而銷燬
4) 經過全局變量加鎖同步來實現通信，也並不利用多個協程對全局變量的讀寫操做。
5) 上面種種分析都在呼喚一個新的通信機制-channel
1) channle 本質就是一個數據結構-隊列
2) 數據是先進先出【FIFO : first in first out】
3) 線程安全，多 goroutine 訪問時，不須要加鎖，就是說 channel 自己就是線程安全的
4) channel 有類型的，一個 string 的 channel 只能存放 string 類型數據。
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
// //若是從channel取出數據後，能夠繼續放入
<-intChan
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*/)
}
1) channel 中只能存放指定的數據類型
2) channle 的數據放滿後，就不能再放入了
3) 若是從 channel 取出數據後，能夠繼續放入
4) 在沒有使用協程的狀況下，若是 channel 數據取完了，再取，就會報 dead lock
package main
import (
"fmt"
)
type Cat struct {
Name string
Age int
}
func main() {
//定義一個存聽任意數據類型的管道 3個數據
//var allChan chan interface{}
allChan := make(chan interface{}, 3)
allChan<- 10
allChan<- "tom jack"
cat := Cat{"小花貓", 4}
allChan<- cat
//咱們但願得到到管道中的第三個元素，則先將前2個推出
<-allChan
<-allChan
newCat := <-allChan //從管道中取出的Cat是什麼?
fmt.Printf("newCat=%T , newCat=%v\n", newCat, newCat)
//下面的寫法是錯誤的!編譯不經過
//fmt.Printf("newCat.Name=%v", newCat.Name)
//使用類型斷言
a := newCat.(Cat)
fmt.Printf("newCat.Name=%v", a.Name)
}
使用內置函數 close 能夠關閉 channel, 當 channel 關閉後，就不能再向 channel 寫數據了，可是仍然能夠從該 channel 讀取數據
channel 支持 for--range 的方式進行遍歷，請注意兩個細節
1) 在遍歷時，若是 channel 沒有關閉，則回出現 deadlock 的錯誤
2) 在遍歷時，若是 channel 已經關閉，則會正常遍歷數據，遍歷完後，就會退出遍歷。
channel 遍歷和關閉的案例演示
package main
import (
"fmt"
)
func main() {
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)
}
}
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, 10)
exitChan := make(chan bool, 1)
go writeData(intChan)
go readData(intChan, exitChan)
time.Sleep(time.Second * 10)
for {
_, ok := <-exitChan
if !ok {
break
}
}
}
若上面的代碼，註釋掉go readData(intChan, exitChan)，會怎樣，由於管道有長度，因此當編譯器發現一個管道只有寫而沒有讀，改管道會阻塞（讀與寫的頻率不一致不要緊）！
需求：
要求統計 1-200000 的數字中，哪些是素數？這個問題在本章開篇就提出了，如今咱們有 goroutine和 channel 的知識後，就能夠完成了 [測試數據: 80000]
分析思路：
傳統的方法，就是使用一個循環，循環的判斷各個數是否是素數【ok】。
使用併發/並行的方式，將統計素數的任務分配給多個(4 個)goroutine 去完成，完成任務時間短。
傳統方法，一個協程
package main
import (
"time"
"fmt"
)
func main() {
start := time.Now().Unix()
for num := 1; num <= 80000; num++ {
flag := true //假設是素數
//判斷num是否是素數
for i := 2; i < num; i++ {
if num % i == 0 {//說明該num不是素數
flag = false
break
}
}
if flag {
//將這個數就放入到primeChan
//primeChan<- num
}
}
end := time.Now().Unix()
fmt.Println("普通的方法耗時=", end - start)
}
開了四個協程
package main
import (
"fmt"
"time"
)
//向 intChan放入 1-8000個數
func putNum(intChan chan int) {
for i := 1; i <= 80000; i++ {
intChan<- i
}
//關閉intChan
close(intChan)
}
// 從 intChan取出數據，並判斷是否爲素數,若是是，就
// //放入到primeChan
func primeNum(intChan chan int, primeChan chan int, exitChan chan bool) {
//使用for 循環
// var num int
var flag bool //
for {
//time.Sleep(time.Millisecond * 10)
num, ok := <-intChan //intChan 取不到..
if !ok {
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, 20000)//放入結果
//標識退出的管道
exitChan := make(chan bool, 8) // 4個
start := time.Now().Unix()
//開啓一個協程，向 intChan放入 1-8000個數
go putNum(intChan)
//開啓4個協程，從 intChan取出數據，並判斷是否爲素數,若是是，就
//放入到primeChan
for i := 0; i < 8; i++ {
go primeNum(intChan, primeChan, exitChan)
}
//這裏咱們主線程，進行處理
//直接
go func(){
for i := 0; i < 8; i++ {
<-exitChan
}
end := time.Now().Unix()
fmt.Println("使用協程耗時=", end - start)
//當咱們從exitChan 取出了4個結果，就能夠放心的關閉 prprimeChan
close(primeChan)
}()
//遍歷咱們的 primeChan ,把結果取出
for {
_, ok := <-primeChan
if !ok{
break
}
//將結果輸出
//fmt.Printf("素數=%d\n", res)
}
fmt.Println("main線程退出")
}
結論：使用 go 協程後，執行的速度，理論上比普通方法提升至少 4 倍(我這是兩倍)
1) channel 能夠聲明爲只讀，或者只寫性質 【案例演示】
package main
import (
"fmt"
)
func main() {
//管道能夠聲明爲只讀或者只寫
//1. 在默認狀況下下，管道是雙向
//var chan1 chan int //可讀可寫
//2 聲明爲只寫
var chan2 chan<- int
chan2 = make(chan int, 3)
chan2<- 20
//num := <-chan2 //error
fmt.Println("chan2=", chan2)
//3. 聲明爲只讀
var chan3 <-chan int
num2 := <-chan3
//chan3<- 30 //err
fmt.Println("num2", num2)
}
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，致使程序崩潰問題
若是咱們開了一個協程，但這個協程出現panic，就會致使整個程序崩潰，這時咱們能夠在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)
}
}