詳解go語言的并發(fā)
更新時間：2021年03月10日 09:32:55 作者：bainianminguo
這篇文章主要介紹了go語言并發(fā)的相關(guān)資料，幫助大家更好的理解和學(xué)習(xí)使用golang，感興趣的朋友可以了解下
1、啟動go語言的協(xié)程
package main
import (
"fmt"
"runtime"
)
//runtime包
func main() {
//runtime.Gosched() 用于讓出cpu時間片，讓出這段cpu的時間片，讓調(diào)度器重新分配資源
//寫一個匿名函數(shù)
s := "test"
go func(s string) {
for i :=0;i <2;i++ {
fmt.Println(s)
}
}(s)
for i :=0;i <2;i ++ {
//如果代碼跑到這里，調(diào)度器會把cpu資源釋放出來，讓調(diào)度器重新分配cpu資源,可以分配到子協(xié)程，也可以重新分配到主協(xié)程
runtime.Gosched()
fmt.Println("123")
}
}
2、runtime.Goexit()方法。立即終止當(dāng)前的協(xié)程
package main
import (
"fmt"
"runtime"
"time"
)
//runtime.Goexit() 立即終止當(dāng)前的協(xié)程
func main() {
go func() {
defer fmt.Println("A.defter")
func () {
defer fmt.Println("B.defter")
//立即終止當(dāng)前的協(xié)程，函數(shù)會走defer流程
runtime.Goexit()
fmt.Println("B")
}()
fmt.Println("A")
}()
for {
time.Sleep(2 * time.Second)
}
}
//不加runtime.Goexit()的結(jié)果
//B
//B.defter
//A
//A.defter
//加runtime.Goexit()的結(jié)果
//B.defter
//A.defter
3、runtime.GOMAXPROCS()表示go使用幾個cpu執(zhí)行代碼
package main
import (
"fmt"
"runtime"
)
func main() {
//runtime.GOMAXPROCS() 表示讓go用幾個cpu做后面的事情
n := runtime.GOMAXPROCS(4)
fmt.Printf("%T--->%p---%d\n",n,n,n)
for {
go fmt.Print("0")
fmt.Print(1)
}
}
4、管道定義和創(chuàng)建管道
package main
import "fmt"
//go語言的協(xié)程運行在相同的地址空間，因此訪問共享內(nèi)存必須做好同步，處理好線程安全問題
//go語言的協(xié)程之間的通信通過協(xié)程間通信來共享內(nèi)存，而不是共享內(nèi)存來通信
//channel是一個引用類型，用于多個協(xié)程間通信，內(nèi)部實現(xiàn)了同步，確保并發(fā)安全
//通道一般是結(jié)合協(xié)程一起使用
//如果通道中沒有數(shù)據(jù)，后面你還去取數(shù)據(jù)，則會報錯
//fatal error: all goroutines are asleep - deadlock!
func main() {
//test45_1 := make(chan int) //定義一個無緩沖的通道
//無緩沖的通道是值在接受數(shù)據(jù)前沒有任何能力保存數(shù)據(jù),只能有一個數(shù)據(jù)進(jìn)入通道，進(jìn)入通道后，該通道就會加鎖，一直到這個數(shù)據(jù)被取出，鎖才釋放
//無緩沖的通道有可能阻塞，如果我發(fā)送一個數(shù)據(jù)到通道，但是沒有協(xié)程來取數(shù)據(jù)，則對于第一個協(xié)程就被阻塞
//test45_2 := make(chan int,10) //定義 一個有緩沖的通道
//有緩沖的通道就是通道可以存儲指定數(shù)量的數(shù)據(jù)，數(shù)據(jù)在里面也是有順序的，但是如果緩沖的數(shù)量滿了，這個通道也會是阻塞的
//
//test45_1 <- 10 //發(fā)送數(shù)據(jù)到通道
//<- test45_1 //接受通道中的數(shù)據(jù)，并丟棄
//x := <-test45_1 //從通道取值并賦值給x
//x,ok := <-test45_1 //ok檢查通道是否關(guān)閉或者是否為空
//1、創(chuàng)建一個存放int類型的通道
test45_1 := make(chan int)
go func() {
defer fmt.Println("子協(xié)程結(jié)束")
fmt.Println("子協(xié)程正在運行")
test45_1 <- 111
}()
//<- test45_1
//主協(xié)程從通道中取數(shù)據(jù)
x := <- test45_1
fmt.Println(x)
fmt.Println("主協(xié)程結(jié)束")
}
5、管道的緩沖
package main
import (
"fmt"
"time"
)
func main() {
//無緩沖的通道，長度為0就可以了，有緩沖的通道，這里設(shè)置為非0就可以了
test46_1 := make(chan int,0)
//%P是打印內(nèi)存地址，%T是打印變量的類型
//fmt.Printf("長度:%d--->容量:%d---->%P----%T",len(test46_1),cap(test46_1),test46_1,test46_1)
go func() {
defer fmt.Printf("子協(xié)程結(jié)束")
for i :=0;i < 3;i ++ {
fmt.Println("子協(xié)程插入數(shù)據(jù)")
test46_1 <- i
//fmt.Printf("長度:%d--->容量:%d---->%P----%T",len(test46_1),cap(test46_1),test46_1,test46_1)
}
}()
time.Sleep(2 * time.Second)
for j :=0;j <3;j++ {
fmt.Println("主協(xié)程取數(shù)據(jù)")
num := <- test46_1
fmt.Println(num)
}
}
6、關(guān)閉管道和接受關(guān)閉管道的信號
package main
import "fmt"
//close（）方法，關(guān)閉通道的意思
func main() {
test47_1 := make(chan int,4)
go func() {
for i :=0;i < 10;i ++ {
test47_1 <- i
}
//這個的意思關(guān)閉通道test47_1
close(test47_1)
}()
//for的寫法,遍歷通道
//for {
// //子協(xié)程關(guān)閉了通道，這里ok就可以接收到，這里就可以走到bread流程,ok這個參數(shù)表示通道是否關(guān)閉
// if data,ok := <- test47_1;ok {
// fmt.Println(data)
// }else {
// break
// }
//}
//range的寫法，遍歷通道
for data := range test47_1 {
fmt.Println(data)
}
fmt.Println("主協(xié)程結(jié)束")
}
7、只讀管道和只寫管道和生產(chǎn)者和消費者模型
package main
import (
"fmt"
"time"
)
//默認(rèn)情況下，管道是雙向的,既可以寫入數(shù)據(jù)，也可以讀出數(shù)據(jù)。go也可以定義單方向的管道，也就是說只發(fā)送數(shù)據(jù)，或者只寫入數(shù)據(jù)
//可以把雙向的管道轉(zhuǎn)換為單向的管道，但是不能把單向的管道轉(zhuǎn)換為雙向的管道
//單方向的管道
func producter(out chan <- int) {
defer close(out)
for i := 0;i < 10;i++ {
out <- i
}
}
func consumer(int <-chan int){
for num := range int {
fmt.Println(num)
}
}
func main() {
//1、定義管道
//定義一個正常的管道
//var test48_1 chan int
//定義一個單向的只寫的管道
//var test48_2 chan <- float32
//定義一個單向的只讀的管道
//var test48_3 <- chan int
//2、轉(zhuǎn)換管道
//轉(zhuǎn)換正常管道為只寫或者只讀的管道
//定義一個正常的管道
//test48_4 := make(chan int,3)
//把一個正常的管道轉(zhuǎn)換為一個只寫的管道
//var write_only chan <- int = test48_4
//把一個正常的管道轉(zhuǎn)換為一個只讀的管道
//var read_only <- chan int = test48_4
test48_5 := make(chan int,4)
//啟動生產(chǎn)者
go producter(test48_5)
//啟動消費者
consumer(test48_5)
time.Sleep(10 * time.Millisecond)
fmt.Println("down")
}
8、Timer定時器
package main
import (
"fmt"
"time"
)
//定時器
//time.NewTimer()。時間到了，只執(zhí)行一次
//time.NewTicker(),周期性的執(zhí)行
func main() {
//1、創(chuàng)建一個定時器，2s后定時器會將一個時間保存到一個C
test49_1 := time.NewTimer(2 * time.Second)
//打印系統(tǒng)當(dāng)前的時間
t1 := time.Now()
fmt.Printf("t1----->%v\n",t1)
//從管道中取出C打印
t2 := <- test49_1.C
fmt.Printf("t2----->%v\n",t2)
//2、證明timer只執(zhí)行一次
//test49_2 := time.NewTimer(4 * time.Second)
//
//for {
// c := <- test49_2.C
// fmt.Println(c)
//}
//3、通過timer實現(xiàn)一個延時的功能
//方式1
//time.Sleep(2 * time.Second)
//方式2
//test49_3 := time.NewTimer(2 * time.Second)
//方式3
//<-time.After(2 *time.Second)
//4、停止定時器
test49_4 := time.NewTimer(4 * time.Second)
//子協(xié)程
go func() {
//這個意思是3s后才能取出來數(shù)據(jù)
<- test49_4.C
fmt.Println("定時器時間到了")
}()
//關(guān)閉定時器
stop := test49_4.Stop()
if stop {
fmt.Println("定時器已經(jīng)關(guān)閉")
}
//5、重置定時器
test49_5 := time.NewTimer(4 * time.Second)
//重置定時器為1s
test49_5.Reset(1 * time.Second)
for {
}
}
9、ticker定時器和關(guān)閉ticker定時器
package main
import (
"fmt"
"time"
)
//time.NewTicker()，定時器，響應(yīng)多次
func main() {
//創(chuàng)建一個定時器，間隔1s
test50_1 := time.NewTicker(time.Second)
i := 0
go func() {
for {
c := <- test50_1.C
fmt.Println(c)
i ++
fmt.Println(i)
}
}()
for {
}
}
10、select語句
package main
import (
"fmt"
)
//go語言提供select關(guān)鍵字，用來監(jiān)聽通道上的數(shù)據(jù)流動，語法和switch類似,區(qū)別是select必須要求每個case語句里必須是一個IO操作
//如果都能匹配到，則隨機選擇一個通道去跑，select是比較隨便的
func main() {
//test51_1 := make(chan int,3)
//select {
//case <- test51_1:
// fmt.Println("jja")
////如果從通道中可以讀出數(shù)據(jù)，則執(zhí)行這里
//case test51_1 <- 1:
// fmt.Println("aa")
////如果通道中北寫入數(shù)據(jù)，則執(zhí)行號這里
//default:
// fmt.Println("hah")
////如果上面都沒成功，則執(zhí)行這里
//}
test51_1 := make(chan int,1)
test51_2 := make(chan string,1)
go func() {
//time.Sleep(2 * time.Second)
test51_1 <- 1
}()
go func() {
test51_2 <- "Hello World"
}()
select {
case Value1:= <- test51_1:
fmt.Println(Value1)
case Value2 := <- test51_2:
fmt.Println(Value2)
}
fmt.Println("結(jié)束")
}
11、協(xié)程同步鎖
package main
import (
"fmt"
"sync"
"time"
)
//go語言的協(xié)程同步鎖，解決并發(fā)安全問題
//取錢的例子
type Account struct {
money int
flag sync.Mutex
}
func Check(a *Account) {
time.Sleep(1 * time.Second)
}
func (a *Account)SetAccount(n int) {
a.money = n
}
func (a *Account)GetAccount() (n int) {
return a.money
}
func (a *Account) buy1(n int) {
a.flag.Lock()
if a.money > n {
Check(a)
a.money -= n
}
a.flag.Unlock()
fmt.Println(a.money)
}
func (a *Account) buy2(n int) {
a.flag.Lock()
if a.money > n {
Check(a)
a.money -= n
}
a.flag.Unlock()
fmt.Println(a.money)
}
func main() {
var test52_1 Account
test52_1.SetAccount(10)
go test52_1.buy1(5)
go test52_1.buy2(6)
for {
}
}
12、wait
我們自己實現(xiàn)wait
package main
import "fmt"
//Add() 計數(shù)加1
//Done() 計數(shù)減1
//Wait() 主函數(shù)調(diào)用
func main() {
test53_1 := make(chan int,2)
count := 2
go func() {
fmt.Println("子協(xié)程1")
test53_1 <- 1
}()
go func() {
fmt.Println("子協(xié)程2")
test53_1 <- 2
}()
for range test53_1 {
count --
if count == 0 {
fmt.Println("所有的子協(xié)程都已經(jīng)結(jié)束")
close(test53_1)
}
}
}
go語言為我們實現(xiàn)wait
package main
import (
"fmt"
"sync"
)
//Add() 計數(shù)加1
//Done() 計數(shù)減1
//Wait() 主函數(shù)調(diào)用
func main() {
var wait_group sync.WaitGroup
//這里就是子協(xié)程的個數(shù)
wait_group.Add(2)
//test54_1 := make(chan int,2)
go func() {
fmt.Println("子協(xié)程1")
wait_group.Done()
}()
go func() {
fmt.Println("子協(xié)程2")
wait_group.Done()
}()
wait_group.Wait()
//close(test53_1)
fmt.Println("所有的子協(xié)程都結(jié)束")
}
以上就是詳解go語言的并發(fā)的詳細(xì)內(nèi)容，更多關(guān)于go語言的并發(fā)的資料請關(guān)注腳本之家其它相關(guān)文章！
您可能感興趣的文章:
- 快速解決Golang Map 并發(fā)讀寫安全的問題
- 淺談golang并發(fā)操作變量安全的問題
- golang高并發(fā)限流操作 ping / telnet
- golang gin 框架 異步同步 goroutine 并發(fā)操作
- Golang 實現(xiàn)分片讀取http超大文件流和并發(fā)控制
- golang-gin-mgo高并發(fā)服務(wù)器搭建教程
- 詳解Go多協(xié)程并發(fā)環(huán)境下的錯誤處理
- Django高并發(fā)負(fù)載均衡實現(xiàn)原理詳解
- golang通過context控制并發(fā)的應(yīng)用場景實現(xiàn)
- 一百行Golang代碼實現(xiàn)簡單并發(fā)聊天室
- 基于Django的樂觀鎖與悲觀鎖解決訂單并發(fā)問題詳解
相關(guān)文章
這篇文章主要來和大家深入討論一下Golang?中的字符串,并查看一些不同的場景,以避免常見錯誤,對大家掌握golang有一定的幫助,需要的可以了解下2023-10-10
Unsafe code是一種繞過go類型安全和內(nèi)存安全檢查的Go代碼。這篇文章主要介紹了go中的unsafe包,需要的朋友可以參考下2019-07-07
這篇文章主要介紹了go語言讀取csv文件并輸出的方法,實例分析了go語言操作csv文件的技巧,需要的朋友可以參考下2015-03-03
tree?命令是一個小型的跨平臺命令行程序，用于遞歸地以樹狀格式列出或顯示目錄的內(nèi)容。本文將通過Go語言實現(xiàn)類似tree命令的小程序，需要的可以參考一下2022-10-10
這篇文章主要介紹了談?wù)剬olang IO讀寫的困惑，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2020-08-08
go語言Pflag Viper Cobra 核心功能使用介紹
這篇文章主要為大家介紹了go語言Pflag Viper Cobra 核心功能使用介紹，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪2022-09-09
大端序和小端序是描述多字節(jié)數(shù)據(jù)在內(nèi)存中存儲順序的術(shù)語,本文主要介紹了Golang中大端序和小端序的處理,具有一定的參考價值,感興趣的可以了解一下2025-02-02
CentOS 32 bit安裝golang 1.7的步驟詳解
Go是Google開發(fā)的一種編譯型，并發(fā)型，并具有垃圾回收功能的編程語言。在發(fā)布了6個rc版本之后，Go 1.7終于正式發(fā)布了。本文主要介紹了在CentOS 32 bit安裝golang 1.7的步驟，文中給出了詳細(xì)的步驟，相信對大家的學(xué)習(xí)和理解具有一定的參考借鑒價值，下面來一起看看吧。2016-12-12
WebSocket是一種在單個TCP連接上進(jìn)行全雙工通信的協(xié)議。這篇文章主要和大家分享了一個Go語言中websocket的使用demo，需要的可以參考一下2022-12-12
這篇文章主要將帶大家一起深入探討 Go 1.20 中 defer 的優(yōu)化機制,并揭示在使用 defer 時需要避免的兩個常見陷阱,有需要的可以了解下2025-03-03