如何在go語言項目中實現并發

這期內容當中小編將會給大家帶來有關如何在go語言項目中實現并發，文章內容豐富且以專業的角度為大家分析和敘述，閱讀完這篇文章希望大家可以有所收獲。

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語言項目中實現并發了，如果剛好有類似的疑惑，不妨參照上述分析進行理解。如果想知道更多相關知識，歡迎關注億速云行業資訊頻道。