详解go语言的并发

怎么入门Golang编程？需要学习哪些知识点？这是新手们刚接触编程时常见的问题；下面golang学习网就来给大家整理分享一些知识点，希望能够给初学者一些帮助。本篇文章就来介绍《详解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、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 

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 容量:%d---->%P----%T",len(test46_1),cap(test46_1),test46_1,test46_1)
 
        }
 
    }()
 
    time.Sleep(2 * time.Second)
    for j :=0;j 

6、关闭管道和接受关闭管道的信号

package main
 
import "fmt"
 
//close（）方法，关闭通道的意思
 
func main() {
    test47_1 := make(chan int,4)
 
    go func() {
        for i :=0;i 

7、只读管道和只写管道和生产者和消费者模型

package main
 
import (
    "fmt"
    "time"
)
 
//默认情况下，管道是双向的,既可以写入数据，也可以读出数据。go也可以定义单方向的管道，也就是说只发送数据，或者只写入数据
 
//可以把双向的管道转换为单向的管道，但是不能把单向的管道转换为双向的管道
 
//单方向的管道
 
func producter(out chan 

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 := %v\n",t2)
 
 
 
    //2、证明timer只执行一次
    //test49_2 := time.NewTimer(4 * time.Second)
    //
    //for {
    //  c := 

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 := 

10、select语句

package main
 
import (
    "fmt"
)
 
//go语言提供select关键字，用来监听通道上的数据流动，语法和switch类似,区别是select必须要求每个case语句里必须是一个IO操作
 
//如果都能匹配到，则随机选择一个通道去跑，select是比较随便的
 
func main() {
    //test51_1 := make(chan int,3)
    //select {
    //case 

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 

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语言的并发》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于golang的知识点！