詳解go語言的并發(fā)
更新時間：2021年03月10日 09:32:55 作者：bainianminguo
這篇文章主要介紹了go語言并發(fā)的相關資料，幫助大家更好的理解和學習使用golang，感興趣的朋友可以了解下
1、啟動go語言的協(xié)程
package main
import (
"fmt"
"runtime"
)
//runtime包
func main() {
//runtime.Gosched() 用于讓出cpu時間片，讓出這段cpu的時間片，讓調度器重新分配資源
//寫一個匿名函數(shù)
s := "test"
go func(s string) {
for i :=0;i <2;i++ {
fmt.Println(s)
}
}(s)
for i :=0;i <2;i ++ {
//如果代碼跑到這里，調度器會把cpu資源釋放出來，讓調度器重新分配cpu資源,可以分配到子協(xié)程，也可以重新分配到主協(xié)程
runtime.Gosched()
fmt.Println("123")
}
}
2、runtime.Goexit()方法。立即終止當前的協(xié)程
package main
import (
"fmt"
"runtime"
"time"
)
//runtime.Goexit() 立即終止當前的協(xié)程
func main() {
go func() {
defer fmt.Println("A.defter")
func () {
defer fmt.Println("B.defter")
//立即終止當前的協(xié)程，函數(shù)會走defer流程
runtime.Goexit()
fmt.Println("B")
}()
fmt.Println("A")
}()
for {
time.Sleep(2 * time.Second)
}
}
//不加runtime.Goexit()的結果
//B
//B.defter
//A
//A.defter
//加runtime.Goexit()的結果
//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é)程運行在相同的地址空間，因此訪問共享內存必須做好同步，處理好線程安全問題
//go語言的協(xié)程之間的通信通過協(xié)程間通信來共享內存，而不是共享內存來通信
//channel是一個引用類型，用于多個協(xié)程間通信，內部實現(xiàn)了同步，確保并發(fā)安全
//通道一般是結合協(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ù)進入通道，進入通道后，該通道就會加鎖，一直到這個數(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檢查通道是否關閉或者是否為空
//1、創(chuàng)建一個存放int類型的通道
test45_1 := make(chan int)
go func() {
defer fmt.Println("子協(xié)程結束")
fmt.Println("子協(xié)程正在運行")
test45_1 <- 111
}()
//<- test45_1
//主協(xié)程從通道中取數(shù)據(jù)
x := <- test45_1
fmt.Println(x)
fmt.Println("主協(xié)程結束")
}
5、管道的緩沖
package main
import (
"fmt"
"time"
)
func main() {
//無緩沖的通道，長度為0就可以了，有緩沖的通道，這里設置為非0就可以了
test46_1 := make(chan int,0)
//%P是打印內存地址，%T是打印變量的類型
//fmt.Printf("長度:%d--->容量:%d---->%P----%T",len(test46_1),cap(test46_1),test46_1,test46_1)
go func() {
defer fmt.Printf("子協(xié)程結束")
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、關閉管道和接受關閉管道的信號
package main
import "fmt"
//close（）方法，關閉通道的意思
func main() {
test47_1 := make(chan int,4)
go func() {
for i :=0;i < 10;i ++ {
test47_1 <- i
}
//這個的意思關閉通道test47_1
close(test47_1)
}()
//for的寫法,遍歷通道
//for {
// //子協(xié)程關閉了通道，這里ok就可以接收到，這里就可以走到bread流程,ok這個參數(shù)表示通道是否關閉
// if data,ok := <- test47_1;ok {
// fmt.Println(data)
// }else {
// break
// }
//}
//range的寫法，遍歷通道
for data := range test47_1 {
fmt.Println(data)
}
fmt.Println("主協(xié)程結束")
}
7、只讀管道和只寫管道和生產者和消費者模型
package main
import (
"fmt"
"time"
)
//默認情況下，管道是雙向的,既可以寫入數(shù)據(jù)，也可以讀出數(shù)據(jù)。go也可以定義單方向的管道，也就是說只發(fā)送數(shù)據(jù)，或者只寫入數(shù)據(jù)
//可以把雙向的管道轉換為單向的管道，但是不能把單向的管道轉換為雙向的管道
//單方向的管道
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、轉換管道
//轉換正常管道為只寫或者只讀的管道
//定義一個正常的管道
//test48_4 := make(chan int,3)
//把一個正常的管道轉換為一個只寫的管道
//var write_only chan <- int = test48_4
//把一個正常的管道轉換為一個只讀的管道
//var read_only <- chan int = test48_4
test48_5 := make(chan int,4)
//啟動生產者
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)當前的時間
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("定時器時間到了")
}()
//關閉定時器
stop := test49_4.Stop()
if stop {
fmt.Println("定時器已經關閉")
}
//5、重置定時器
test49_5 := time.NewTimer(4 * time.Second)
//重置定時器為1s
test49_5.Reset(1 * time.Second)
for {
}
}
9、ticker定時器和關閉ticker定時器
package main
import (
"fmt"
"time"
)
//time.NewTicker()，定時器，響應多次
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關鍵字，用來監(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("結束")
}
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ù)調用
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é)程都已經結束")
close(test53_1)
}
}
}
go語言為我們實現(xiàn)wait
package main
import (
"fmt"
"sync"
)
//Add() 計數(shù)加1
//Done() 計數(shù)減1
//Wait() 主函數(shù)調用
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é)程都結束")
}
以上就是詳解go語言的并發(fā)的詳細內容，更多關于go語言的并發(fā)的資料請關注腳本之家其它相關文章！
您可能感興趣的文章:
- 快速解決Golang Map 并發(fā)讀寫安全的問題
- 淺談golang并發(fā)操作變量安全的問題
- golang高并發(fā)限流操作 ping / telnet
- golang gin 框架 異步同步 goroutine 并發(fā)操作
- Golang 實現(xiàn)分片讀取http超大文件流和并發(fā)控制
- golang-gin-mgo高并發(fā)服務器搭建教程
- 詳解Go多協(xié)程并發(fā)環(huán)境下的錯誤處理
- Django高并發(fā)負載均衡實現(xiàn)原理詳解
- golang通過context控制并發(fā)的應用場景實現(xiàn)
- 一百行Golang代碼實現(xiàn)簡單并發(fā)聊天室
- 基于Django的樂觀鎖與悲觀鎖解決訂單并發(fā)問題詳解
相關文章
golang框架gin的日志處理和zap lumberjack日志使用方式
這篇文章主要介紹了golang框架gin的日志處理和zap lumberjack日志使用方式,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2024-01-01
在Go語言中,條件語句的使用方式相對簡潔明了,所以本文將探討一下如何在Go程序中有效地進行條件判斷和邏輯控制,感興趣的小伙伴可以了解下2023-08-08
go語言題解LeetCode1299將每個元素替換為右側最大元素
這篇文章主要為大家介紹了go語言LeetCode刷題1299將每個元素替換為右側最大元素示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2023-01-01
Golang實現(xiàn)對map的并發(fā)讀寫的方法示例
這篇文章主要介紹了Golang實現(xiàn)對map的并發(fā)讀寫的方法示例，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2019-03-03
這篇文章主要介紹了Golang空結構體struct{}用途,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2021-01-01
自定義類型是 Go 語言中非常重要的概念之一，通過自定義類型，我們可以更好地封裝數(shù)據(jù)、組織代碼，提高程序的可讀性和可維護性。本文將從以下幾個方面介紹 Go 自定義類型的相關知識，感興趣的可以了解一下2023-04-04
這篇文章將給大家介紹了go語言中函數(shù)new與make的使用和區(qū)別,關于go語言中new和make是內建的兩個函數(shù),主要用來創(chuàng)建分配類型內存,文中通過代碼示例介紹的非常詳細,具有一定的參考價值,需要的朋友可以參考下2024-01-01
這篇文章主要介紹了一文搞懂Golang文件操作增刪改查功能(基礎篇),Golang 可以認為是服務器開發(fā)語言發(fā)展的趨勢之一，特別是在流媒體服務器開發(fā)中，已經占有一席之地，今天我們不聊特別深奧的機制和內容，就來聊一聊 Golang 對于文件的基本操作2021-04-04
panic?和?recover?是?Go?語言中用于處理異常和錯誤的機制,能夠幫助我們應對意外情況并使程序更加健壯,這篇文章主要介紹了GoLang中panic和recover作用詳解,需要的朋友可以參考下2024-05-05
本文主要介紹了Golang執(zhí)行cmd命令行的方法，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2022-08-08