目錄
- 1、啟動go語言的協程
- 2、runtime.Goexit()方法。立即終止當前的協程
- 3、runtime.GOMAXPROCS()表示go使用幾個cpu執行代碼
- 4、管道定義和創建管道
- 5、管道的緩沖
- 6、關閉管道和接受關閉管道的信號
- 7、只讀管道和只寫管道和生產者和消費者模型
- 8、Timer定時器
- 9、ticker定時器和關閉ticker定時器
- 10、select語句
- 11、協程同步鎖
- 12、wait
1、啟動go語言的協程
package main
import (
"fmt"
"runtime"
)
//runtime包
func main() {
//runtime.Gosched() 用于讓出cpu時間片，讓出這段cpu的時間片，讓調度器重新分配資源
//寫一個匿名函數
s := "test"
go func(s string) {
for i :=0;i 2;i++ {
fmt.Println(s)
}
}(s)
for i :=0;i 2;i ++ {
//如果代碼跑到這里，調度器會把cpu資源釋放出來，讓調度器重新分配cpu資源,可以分配到子協程，也可以重新分配到主協程
runtime.Gosched()
fmt.Println("123")
}
}
2、runtime.Goexit()方法。立即終止當前的協程
package main
import (
"fmt"
"runtime"
"time"
)
//runtime.Goexit() 立即終止當前的協程
func main() {
go func() {
defer fmt.Println("A.defter")
func () {
defer fmt.Println("B.defter")
//立即終止當前的協程，函數會走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執行代碼
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、管道定義和創建管道
package main
import "fmt"
//go語言的協程運行在相同的地址空間，因此訪問共享內存必須做好同步，處理好線程安全問題
//go語言的協程之間的通信通過協程間通信來共享內存，而不是共享內存來通信
//channel是一個引用類型，用于多個協程間通信，內部實現了同步，確保并發安全
//通道一般是結合協程一起使用
//如果通道中沒有數據，后面你還去取數據，則會報錯
//fatal error: all goroutines are asleep - deadlock!
func main() {
//test45_1 := make(chan int) //定義一個無緩沖的通道
//無緩沖的通道是值在接受數據前沒有任何能力保存數據,只能有一個數據進入通道，進入通道后，該通道就會加鎖，一直到這個數據被取出，鎖才釋放
//無緩沖的通道有可能阻塞，如果我發送一個數據到通道，但是沒有協程來取數據，則對于第一個協程就被阻塞
//test45_2 := make(chan int,10) //定義 一個有緩沖的通道
//有緩沖的通道就是通道可以存儲指定數量的數據，數據在里面也是有順序的，但是如果緩沖的數量滿了，這個通道也會是阻塞的
//
//test45_1 - 10 //發送數據到通道
//- test45_1 //接受通道中的數據，并丟棄
//x := -test45_1 //從通道取值并賦值給x
//x,ok := -test45_1 //ok檢查通道是否關閉或者是否為空
//1、創建一個存放int類型的通道
test45_1 := make(chan int)
go func() {
defer fmt.Println("子協程結束")
fmt.Println("子協程正在運行")
test45_1 - 111
}()
//- test45_1
//主協程從通道中取數據
x := - test45_1
fmt.Println(x)
fmt.Println("主協程結束")
}
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("子協程結束")
for i :=0;i 3;i ++ {
fmt.Println("子協程插入數據")
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("主協程取數據")
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 {
// //子協程關閉了通道，這里ok就可以接收到，這里就可以走到bread流程,ok這個參數表示通道是否關閉
// if data,ok := - test47_1;ok {
// fmt.Println(data)
// }else {
// break
// }
//}
//range的寫法，遍歷通道
for data := range test47_1 {
fmt.Println(data)
}
fmt.Println("主協程結束")
}
7、只讀管道和只寫管道和生產者和消費者模型
package main
import (
"fmt"
"time"
)
//默認情況下，管道是雙向的,既可以寫入數據，也可以讀出數據。go也可以定義單方向的管道，也就是說只發送數據，或者只寫入數據
//可以把雙向的管道轉換為單向的管道，但是不能把單向的管道轉換為雙向的管道
//單方向的管道
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()。時間到了，只執行一次
//time.NewTicker(),周期性的執行
func main() {
//1、創建一個定時器，2s后定時器會將一個時間保存到一個C
test49_1 := time.NewTimer(2 * time.Second)
//打印系統當前的時間
t1 := time.Now()
fmt.Printf("t1----->%v\n",t1)
//從管道中取出C打印
t2 := - test49_1.C
fmt.Printf("t2----->%v\n",t2)
//2、證明timer只執行一次
//test49_2 := time.NewTimer(4 * time.Second)
//
//for {
// c := - test49_2.C
// fmt.Println(c)
//}
//3、通過timer實現一個延時的功能
//方式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)
//子協程
go func() {
//這個意思是3s后才能取出來數據
- 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() {
//創建一個定時器，間隔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關鍵字，用來監聽通道上的數據流動，語法和switch類似,區別是select必須要求每個case語句里必須是一個IO操作
//如果都能匹配到，則隨機選擇一個通道去跑，select是比較隨便的
func main() {
//test51_1 := make(chan int,3)
//select {
//case - test51_1:
// fmt.Println("jja")
////如果從通道中可以讀出數據，則執行這里
//case test51_1 - 1:
// fmt.Println("aa")
////如果通道中北寫入數據，則執行號這里
//default:
// fmt.Println("hah")
////如果上面都沒成功，則執行這里
//}
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、協程同步鎖
package main
import (
"fmt"
"sync"
"time"
)
//go語言的協程同步鎖，解決并發安全問題
//取錢的例子
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
我們自己實現wait
package main
import "fmt"
//Add() 計數加1
//Done() 計數減1
//Wait() 主函數調用
func main() {
test53_1 := make(chan int,2)
count := 2
go func() {
fmt.Println("子協程1")
test53_1 - 1
}()
go func() {
fmt.Println("子協程2")
test53_1 - 2
}()
for range test53_1 {
count --
if count == 0 {
fmt.Println("所有的子協程都已經結束")
close(test53_1)
}
}
}
go語言為我們實現wait
package main
import (
"fmt"
"sync"
)
//Add() 計數加1
//Done() 計數減1
//Wait() 主函數調用
func main() {
var wait_group sync.WaitGroup
//這里就是子協程的個數
wait_group.Add(2)
//test54_1 := make(chan int,2)
go func() {
fmt.Println("子協程1")
wait_group.Done()
}()
go func() {
fmt.Println("子協程2")
wait_group.Done()
}()
wait_group.Wait()
//close(test53_1)
fmt.Println("所有的子協程都結束")
}
以上就是詳解go語言的并發的詳細內容，更多關于go語言的并發的資料請關注腳本之家其它相關文章！
您可能感興趣的文章:- 快速解決Golang Map 并發讀寫安全的問題
- 淺談golang并發操作變量安全的問題
- golang高并發限流操作 ping / telnet
- golang gin 框架 異步同步 goroutine 并發操作
- Golang 實現分片讀取http超大文件流和并發控制
- golang-gin-mgo高并發服務器搭建教程
- 詳解Go多協程并發環境下的錯誤處理
- Django高并發負載均衡實現原理詳解
- golang通過context控制并發的應用場景實現
- 一百行Golang代碼實現簡單并發聊天室
- 基于Django的樂觀鎖與悲觀鎖解決訂單并發問題詳解
