详解go语言的并发
1、启动go语言的协程
packagemain import( "fmt" "runtime" ) //runtime包 funcmain(){ //runtime.Gosched()用于让出cpu时间片,让出这段cpu的时间片,让调度器重新分配资源 //写一个匿名函数 s:="test" gofunc(sstring){ fori:=0;i<2;i++{ fmt.Println(s) } }(s) fori:=0;i<2;i++{ //如果代码跑到这里,调度器会把cpu资源释放出来,让调度器重新分配cpu资源,可以分配到子协程,也可以重新分配到主协程 runtime.Gosched() fmt.Println("123") } }
2、runtime.Goexit()方法。立即终止当前的协程
packagemain import( "fmt" "runtime" "time" ) //runtime.Goexit() 立即终止当前的协程 funcmain(){ gofunc(){ deferfmt.Println("A.defter") func(){ deferfmt.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执行代码
packagemain import( "fmt" "runtime" ) funcmain(){ //runtime.GOMAXPROCS()表示让go用几个cpu做后面的事情 n:=runtime.GOMAXPROCS(4) fmt.Printf("%T--->%p---%d\n",n,n,n) for{ gofmt.Print("0") fmt.Print(1) } }
4、管道定义和创建管道
packagemain import"fmt" //go语言的协程运行在相同的地址空间,因此访问共享内存必须做好同步,处理好线程安全问题 //go语言的协程之间的通信通过协程间通信来共享内存,而不是共享内存来通信 //channel是一个引用类型,用于多个协程间通信,内部实现了同步,确保并发安全 //通道一般是结合协程一起使用 //如果通道中没有数据,后面你还去取数据,则会报错 //fatalerror:allgoroutinesareasleep-deadlock! funcmain(){ //test45_1:=make(chanint)//定义一个无缓冲的通道 //无缓冲的通道是值在接受数据前没有任何能力保存数据,只能有一个数据进入通道,进入通道后,该通道就会加锁,一直到这个数据被取出,锁才释放 //无缓冲的通道有可能阻塞,如果我发送一个数据到通道,但是没有协程来取数据,则对于第一个协程就被阻塞 //test45_2:=make(chanint,10) //定义一个有缓冲的通道 //有缓冲的通道就是通道可以存储指定数量的数据,数据在里面也是有顺序的,但是如果缓冲的数量满了,这个通道也会是阻塞的 // //test45_1<-10 //发送数据到通道 //<-test45_1 //接受通道中的数据,并丢弃 //x:=<-test45_1//从通道取值并赋值给x //x,ok:=<-test45_1 //ok检查通道是否关闭或者是否为空 //1、创建一个存放int类型的通道 test45_1:=make(chanint) gofunc(){ deferfmt.Println("子协程结束") fmt.Println("子协程正在运行") test45_1<-111 }() //<-test45_1 //主协程从通道中取数据 x:=<-test45_1 fmt.Println(x) fmt.Println("主协程结束") }
5、管道的缓冲
packagemain import( "fmt" "time" ) funcmain(){ //无缓冲的通道,长度为0就可以了,有缓冲的通道,这里设置为非0就可以了 test46_1:=make(chanint,0) //%P是打印内存地址,%T是打印变量的类型 //fmt.Printf("长度:%d--->容量:%d---->%P----%T",len(test46_1),cap(test46_1),test46_1,test46_1) gofunc(){ deferfmt.Printf("子协程结束") fori:=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) forj:=0;j<3;j++{ fmt.Println("主协程取数据") num:=<-test46_1 fmt.Println(num) } }
6、关闭管道和接受关闭管道的信号
packagemain import"fmt" //close()方法,关闭通道的意思 funcmain(){ test47_1:=make(chanint,4) gofunc(){ fori:=0;i<10;i++{ test47_1<-i } //这个的意思关闭通道test47_1 close(test47_1) }() //for的写法,遍历通道 //for{ // //子协程关闭了通道,这里ok就可以接收到,这里就可以走到bread流程,ok这个参数表示通道是否关闭 // ifdata,ok:=<-test47_1;ok{ // fmt.Println(data) // }else{ // break // } //} //range的写法,遍历通道 fordata:=rangetest47_1{ fmt.Println(data) } fmt.Println("主协程结束") }
7、只读管道和只写管道和生产者和消费者模型
packagemain import( "fmt" "time" ) //默认情况下,管道是双向的,既可以写入数据,也可以读出数据。go也可以定义单方向的管道,也就是说只发送数据,或者只写入数据 //可以把双向的管道转换为单向的管道,但是不能把单向的管道转换为双向的管道 //单方向的管道 funcproducter(outchan<-int) { deferclose(out) fori:=0;i<10;i++{ out<-i } } funcconsumer(int<-chanint){ fornum:=rangeint{ fmt.Println(num) } } funcmain(){ //1、定义管道 //定义一个正常的管道 //vartest48_1chanint //定义一个单向的只写的管道 //vartest48_2chan<-float32 //定义一个单向的只读的管道 //vartest48_3<-chanint //2、转换管道 //转换正常管道为只写或者只读的管道 //定义一个正常的管道 //test48_4:=make(chanint,3) //把一个正常的管道转换为一个只写的管道 //varwrite_onlychan<-int=test48_4 //把一个正常的管道转换为一个只读的管道 //varread_only<-chanint=test48_4 test48_5:=make(chanint,4) //启动生产者 goproducter(test48_5) //启动消费者 consumer(test48_5) time.Sleep(10*time.Millisecond) fmt.Println("down") }
8、Timer定时器
packagemain import( "fmt" "time" ) //定时器 //time.NewTimer()。时间到了,只执行一次 //time.NewTicker(),周期性的执行 funcmain(){ //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) //子协程 gofunc(){ //这个意思是3s后才能取出来数据 <-test49_4.C fmt.Println("定时器时间到了") }() //关闭定时器 stop:=test49_4.Stop() ifstop{ fmt.Println("定时器已经关闭") } //5、重置定时器 test49_5:=time.NewTimer(4*time.Second) //重置定时器为1s test49_5.Reset(1*time.Second) for{ } }
9、ticker定时器和关闭ticker定时器
packagemain import( "fmt" "time" ) //time.NewTicker(),定时器,响应多次 funcmain(){ //创建一个定时器,间隔1s test50_1:=time.NewTicker(time.Second) i:=0 gofunc(){ for{ c:=<-test50_1.C fmt.Println(c) i++ fmt.Println(i) } }() for{ } }
10、select语句
packagemain import( "fmt" ) //go语言提供select关键字,用来监听通道上的数据流动,语法和switch类似,区别是select必须要求每个case语句里必须是一个IO操作 //如果都能匹配到,则随机选择一个通道去跑,select是比较随便的 funcmain(){ //test51_1:=make(chanint,3) //select{ //case<-test51_1: // fmt.Println("jja") ////如果从通道中可以读出数据,则执行这里 //casetest51_1<-1: // fmt.Println("aa") ////如果通道中北写入数据,则执行号这里 //default: // fmt.Println("hah") ////如果上面都没成功,则执行这里 //} test51_1:=make(chanint,1) test51_2:=make(chanstring,1) gofunc(){ //time.Sleep(2*time.Second) test51_1<-1 }() gofunc(){ test51_2<-"HelloWorld" }() select{ caseValue1:=<-test51_1: fmt.Println(Value1) caseValue2:=<-test51_2: fmt.Println(Value2) } fmt.Println("结束") }
11、协程同步锁
packagemain import( "fmt" "sync" "time" ) //go语言的协程同步锁,解决并发安全问题 //取钱的例子 typeAccountstruct{ moneyint flagsync.Mutex } funcCheck(a*Account) { time.Sleep(1*time.Second) } func(a*Account)SetAccount(nint) { a.money=n } func(a*Account)GetAccount()(nint){ returna.money } func(a*Account)buy1(nint) { a.flag.Lock() ifa.money>n{ Check(a) a.money-=n } a.flag.Unlock() fmt.Println(a.money) } func(a*Account)buy2(nint) { a.flag.Lock() ifa.money>n{ Check(a) a.money-=n } a.flag.Unlock() fmt.Println(a.money) } funcmain(){ vartest52_1Account test52_1.SetAccount(10) gotest52_1.buy1(5) gotest52_1.buy2(6) for{ } }
12、wait
我们自己实现wait
packagemain import"fmt" //Add()计数加1 //Done()计数减1 //Wait()主函数调用 funcmain(){ test53_1:=make(chanint,2) count:=2 gofunc(){ fmt.Println("子协程1") test53_1<-1 }() gofunc(){ fmt.Println("子协程2") test53_1<-2 }() forrangetest53_1{ count-- ifcount==0{ fmt.Println("所有的子协程都已经结束") close(test53_1) } } }
go语言为我们实现wait
packagemain import( "fmt" "sync" ) //Add()计数加1 //Done()计数减1 //Wait()主函数调用 funcmain(){ varwait_groupsync.WaitGroup //这里就是子协程的个数 wait_group.Add(2) //test54_1:=make(chanint,2) gofunc(){ fmt.Println("子协程1") wait_group.Done() }() gofunc(){ fmt.Println("子协程2") wait_group.Done() }() wait_group.Wait() //close(test53_1) fmt.Println("所有的子协程都结束") }
以上就是详解go语言的并发的详细内容,更多关于go语言的并发的资料请关注毛票票其它相关文章!
声明:本文内容来源于网络,版权归原作者所有,内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎发送邮件至:czq8825#qq.com(发邮件时,请将#更换为@)进行举报,并提供相关证据,一经查实,本站将立刻删除涉嫌侵权内容。