go語言並發編程
阿新 • • 發佈:2018-11-14
默認 water () blog 編譯器 數組 非阻塞 sch 傳統 一、goroutine
與傳統的系統級線程和進程相比,協程的大優勢在於其“輕量級”,可以輕松創建上百萬個而不會導致系統資源衰竭,而線程和進程通常多也不能超過1萬個。這也是協程也叫輕量級線程的原因。
golang原生支持並發編程
輕量級線程
非搶占式多任務處理,由協程主動交出控制權
編譯器/解釋器/虛擬機層面的多任務
多個協程可能在一個或多個線程上運行
1.1 go對協程的實現
goroutine--Go對協程的實現
go + 函數名:啟動一個協程執行函數體
package main import ( "fmt" "time" ) func test_Routine() { fmt.Println("This is one routine!!!") } func Add(x, y int) { z := x + y fmt.Println(z) } func main() { for i := 1; i < 10; i++ { //啟動一個協程執行函數體 go Add(i, i) } //為避免並發執行後程序立即退出,先sleep 2秒 time.Sleep(2) }
package main import ( "fmt" "runtime" "time" ) func main() { //定義一個數組 var a [10]int //循環並發執行匿名函數,實現 for i := 0; i < 10; i ++ { go func(i int) { for { a[i]++ //主動讓go協程讓出時間片 runtime.Gosched() } }(i) } time.Sleep(time.Millisecond) fmt.Println(a) }
二、channel
Go語言在語言級別提供的goroutine間的通信方式
不要通過共享來通信,而要通過通信來共享。
channel的讀寫默認是阻塞的,除非有goroutine對其進行操作。
package main import ( "fmt" "strconv" ) //定義一個加法函數,傳入x,y整型參數,quit整型通道 func Add(x, y int, quit chan int) { z := x + y fmt.Println(z) //發送 1 到channel quit quit <- 1 } //讀取channel中的數據 func Read(ch chan int) { //將channel中數據發送出去,賦值給value value := <-ch fmt.Println("value:" + strconv.Itoa(value)) } //寫數據到channel中 func Write(ch chan int) { //ch <- 10 } func main() { //ch := make(chan int) //go Read(ch) //go Write(ch) //time.Sleep(10) //fmt.Println("end of code") //定義一個容量為10的非阻塞整型通道切片,變 量名為chs chs := make([]chan int, 10) //循環地給channel切片chs初始化 for i := 0; i < 10; i++ { chs[i] = make(chan int) go Add(i, i, chs[i]) } //遍歷channel切片chs,並從channel中發出數據,留空 for _, v := range chs { <-v } }
三、緩沖channel
定義: c = make(chan int, n) n為緩沖區的大小,代表channel可以存儲多少個元素,這幾個元素可以無阻塞的寫入,緩存的元素寫滿之後阻塞,除非有goroutine操作。
例子中定義一個容量為2的channel,
// 緩沖channel
package main
import (
"fmt"
"time"
)
// 定義一個chnnel類型變量 ch
var ch chan int
//測試buffered channel函數
func test_channel() {
// 第一次發送常量1到channel ch
ch <- 1
fmt.Println("ch 1")
// 第二次發送常量1到channel ch
ch <- 1
fmt.Println("ch 2")
// 第三次發送常量1到channel ch
ch <- 1
fmt.Println("come to end goroutine 1")
}
func main() {
ch = make(chan int, 0) // 等價於 ch = make(chan int) 都是不帶緩沖的channel
ch = make(chan int, 2) // 是帶緩沖的channel
go test_channel()
time.Sleep(2 * time.Second)
fmt.Println("running end!")
<-ch
time.Sleep(time.Second)
}
output:
ch 1
ch 2
running end!
come to end goroutine 1
package main
import "fmt"
func main() {
c := make(chan int, 3 )//修改2為1就報錯,修改2為3可以正常運行
c <- 1
c <- 2
fmt.Println(<-c)
fmt.Println(<-c)
}
四、select
Linux很早就引入的函數,用來實現非阻塞的一種方式。Go語言直接在語言級別支持select關鍵字,用於處理異步IO 問題。我們上面介紹的都是只有一個channel的情況,那麽如果存在多個channel的時候,我們該如何操作呢,Go裏面提供了一個關鍵字select,通過select可以監聽channel上的數據流動。
select默認是阻塞的,只有當監聽的channel中有發送或接收可以進行時才會運行,當多個channel都準備好的時候,select是隨機的選擇一個執行的。
package main
import (
"fmt"
"time"
)
func main() {
ch := make(chan int)
//匿名函數,傳入一個參數整型channel類型ch
go func(ch chan int) {
ch <- 1
}(ch)
time.Sleep(time.Second)
select {
//如果ch成功讀到數據,則執行下面的語句
case <-ch:
fmt.Print("come to read ch!")
default:
fmt.Print("come to default!")
}
}
// 實現超時控制
package main
import (
"fmt"
"time"
)
func main() {
ch := make(chan int)
//定義一個channel timeout
timeout := make(chan int, 1)
//定義一個匿名函數,用來實現超時控制
go func() {
time.Sleep( time.Second)
timeout <- 1
}()
select {
case <-ch:
fmt.Print("come to read ch!\n")
case <-timeout:
fmt.Print("come to timeout!\n")
}
fmt.Print("end of code!")
}
// 使用time.After(time.Second)實現控制
package main
import (
"fmt"
"time"
)
func main() {
ch := make(chan int)
select {
case <-ch:
fmt.Print("come to read ch!\n")
case <-time.After(time.Second):
fmt.Print("come to timeout!\n")
}
fmt.Print("end of code!")
}
// goroutine_2.go
package main
import (
"fmt"
"runtime"
"strconv"
"time"
)
func main() {
//協程1
go func() {
for i := 1; i < 100; i++ {
if i == 10 {
//主動出讓cpu 使用的話 需要 導入 runtime包
runtime.Gosched()
}
fmt.Println("routine 1:" + strconv.Itoa(i))
}
}()
//協程2
go func() {
for i := 100; i < 200; i++ {
fmt.Println("routine 2:" + strconv.Itoa(i))
}
}()
time.Sleep(time.Second)
}
go語言並發編程