Go语言协程使用
主协程执行打印，子协程不打印
package main
import (
"fmt"
)
func do(i int) {
fmt.Println("执行中")
}
func main() {
fmt.Println("main协程")
go do(1)
fmt.Println("执行完了")
}
//main协程
//执行完了
子协程没有打印输出
原因：主和子协程各执行各的，当主协程执行完go语句就退出，并不会等待子协程执行完成
解决办法三个：
sync. WaitGroup的三个方法 Add(), Done(), Wait()
package main
import (
"fmt"
"sync"
)
func do(i int) {
fmt.Println("do执行中", i)
}
func main() {
var wg sync.WaitGroup
fmt.Println("main协程")
wg.Add(1)
go func(i int) {
defer wg.Done()
do(i)
}(1)
wg.Wait()
fmt.Println("执行完了")
}
//main协程
//do执行中 1
//执行完了
channel来控制协程
package main
import (
"fmt"
)
func do(i int) {
fmt.Println("do执行中", i)
}
func main() {
ch := make(chan bool, 1)
fmt.Println("main协程")
go func(i int, chp chan<- bool) {
defer close(chp)
A(i)
fmt.Println("do执行完")
chp <- true
}(1, ch)
fmt.Println("wait")
<-ch
fmt.Println("main执行完了")
}
//main协程
//wait
//do执行中 1
//do执行完
//main执行完了
通过sync. Cond来实现
package main
import (
"fmt"
"sync"
)
func do(i int) {
fmt.Println("do执行中", i)
}
func main() {
var locker = new(sync.Mutex)
var cond = sync.NewCond(locker)
var done bool = false
fmt.Println("main")
cond.L.Lock()
go func(i int) {
do(i)
fmt.Println("do完成")
done = true
cond.Signal()
}(1)
fmt.Println("wait")
if !done {
cond.Wait()
cond.L.Unlock()
}
fmt.Println("main完成")
}
//main
//do执行中
//do完成
//main完成
会出现的问题：协程崩溃，主协程也会停止
go可以通过recover来捕获panic，类似try catch的作用
注意
- recover如果想起作用的话， 必须在defered函数前声明，因为只要panic，后面的函数不会被执行
- recover函数只有在方法内部发生panic时，返回值才不会为nil，没有panic的情况下返回值为nil
package main
import (
"fmt"
"sync"
)
func do(i int) {
fmt.Println("do执行中", i)
panic("崩溃")
defer func() { //在panic后声明defer,不能捕获异常
if err := recover(); err != nil {
fmt.Println("恢复", err)
}
}()
}
func main() {
var wg sync.WaitGroup
fmt.Println("main协程")
wg.Add(1)
go func(i int) {
defer wg.Done()
A(i)
}(1)
wg.Wait()
fmt.Println("main执行完了")
}
main协程
do执行中 1
main执行完了
panic: 崩溃
//goroutine 6 [running]:
//main.do(0x0?)
// /Volumes/disk/site/go/demo/gfqa/main.go:11 +0x88
//main.main.func1(0x0?)
// /Volumes/disk/site/go/demo/gfqa/main.go:28 +0x4c
//created by main.main
// /Volumes/disk/site/go/demo/gfqa/main.go:26 +0x100
//进程 已完成，退出代码为 2
改进：panic前声明recover
package main
import (
"fmt"
"sync"
)
func do(i int) {
fmt.Println("do执行中", i)
defer func() { //在panic后声明defer,不能捕获异常
if err := recover(); err != nil {
fmt.Println("恢复", err)
}
}()
panic("崩溃")
}
func main() {
var wg sync.WaitGroup
fmt.Println("main协程")
wg.Add(1)
go func(i int) {
defer wg.Done()
A(i)
}(1)
wg.Wait()
fmt.Println("main执行完了")
}
//do执行中 1
//恢复 崩溃
//main执行完了
其他写法
func do(i int) {
fmt.Println("do执行中", i)
panic("崩溃")
}
func main() {
var wg sync.WaitGroup
fmt.Println("main协程")
wg.Add(1)
go func(i int) {
defer func() {
if err := recover(); err != nil {
fmt.Println("恢复", err)
}
wg.Done()
}()
do(i)
}(1)
wg.Wait()
fmt.Println("main执行完了")
}
总结：如果在协程内执行其它函数时，为了保证不崩溃，安全的做法是，提前声明defer recover函数
协程超时控制
用select + channel来进行超时控制
超时 ： ctx. Done()或者time. After()或者time. Ticket()
select捕获到其中一个channel有数据，就执行对应的代码，然后退出
注意：channel要用有缓冲的，不然，在超时分支退出时，协程还在卡住，造成goroutine泄露
func do(ctx context.Context, wg *sync.WaitGroup) {
ctx, cancle := context.WithTimeout(ctx, time.Second*2)
defer func() {
cancle()
wg.Done()
}()
done := make(chan struct{}, 1) //执行成功的channel
go func(ctx context.Context) {
fmt.Println("go goroutine")
time.Sleep(time.Second * 10)
done <- struct{}{} //发送完成的信号
}(ctx)
select {
case <-ctx.Done(): //超时
fmt.Printf("timeout,err:%v\n", ctx.Err())
case <-time.After(3 * time.Second): //超时
fmt.Printf("after 1 sec.")
case <-done: //程序正常结束
fmt.Println("done")
}
}
func main() {
fmt.Println("main协程")
ctx := context.Background()
var wg sync.WaitGroup
wg.Add(1)
do(ctx, &wg)
wg.Wait()
fmt.Println("main执行完成")
}
//main协程
//go goroutine
//timeout,err:context deadline exceeded
//main执行完成
总结：runtime. GOMAXPROCS()可以控制当前程序运行时占用的系统核心数，
一个协程不对应一个os线程，是一个m:n的对应关系，协程对应的os线程runtime. GOMAXPROCS默认为系统逻辑cpu数量
原文地址：https://blog.csdn.net/u014617119/article/details/135721988
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！