goroutine的使用

博主：欣七天
发布时间：2023 年 03 月 08 日
235 次浏览
暂无评论
2915字数
分类：并发

# goroutine的使用

## 一、简介

GO是并发语言，不是并行语言。

goroutine中没有返回值，一般是通过channel进行goroutine之间的通信的。

## 二、goroutine调度原理

### 调度器架构

Go的调度器从最开始的单线程经过不断的改进、优化，发展到现在的GMP模型，在GMP模型中有三个重要的结构：

- G(Goroutine)：go协程，一个可执行单元，调度器作用就是对所有G的切换
- M(Thread)：操作系统上的线程，G运行与M上，一个G可能由多个不同的M运行，一个M可以运行多个G
- P(Processor)：处理器，他包含了运行G的资源，如果线程M想运行G，必须先获取P，P还包含了可运行的G队列。一个M一个时刻只拥有一个P，M和P的数量是1：1的。

### 调度策略

#### 复用线程

调度器核心思想是尽可能避免频繁的创建、销毁线程，对线程进行复用以提高效率。
**1. work stealing机制（窃取式）**
当本线程无G可运行时，尝试从其他线程绑定的P窃取G，而不是直接销毁线程。
**2. hand off机制**
当本线程M因为G进行的系统调用阻塞是，线程释放绑定的P，把P转移给其他空闲的M'执行。

##### 利用多核CPU并行

`GOMAXPROCS`设置P的数量，最多有`GOMAXPROCS`个线程分布在多个CPU核心上运行。`runtime.GOMAXPROCS(N)`修改，N表示设置的个数

#### 抢占

一个goroutine最多占用CPU10ms，防止其他goroutine等待太久得不到执行被“饿死”。

#### 全局G队列

全局G队列是有互斥锁保护的，访问需要竞争锁，新的调度器将其功能弱化了，当M执行work stealing从其他P窃取不到G时，才会去全局G队列获取G。

## 三、goroutine应用

### 基础应用

```
package main

import "fmt"

func demoTest() {
	for i := 0; i < 500; i++ {
		fmt.Println("goroutine输出结果：", i)
	}
}

func main() {
	go demoTest()
	for i := 1; i < 500; i++ {
		fmt.Println("main输出结果：", i)
	}
}
```

![avatar](http://type.zimopy.com/usr/uploads/2023/03/3602092283.png)

> goroutine的两个特点：
>
> 1.goroutine协程中的函数执行和主函数的执行是同时进行的，输出的内容是交替的。
>
> 2.主程序结束后，即使goroutine没有执行完成，也会随着主程序一同结束。

### sync.WaitGroup![1678092824227.png](http://type.zimopy.com/usr/uploads/2023/03/496577956.png)

实现主线程不退出，等待协程组的完成

```
package main

import (
	"fmt"
	"sync"
)

func demoTest() {
	fmt.Println("demoTest函数")
}

func main() {
	fmt.Println("main函数")
	var wg sync.WaitGroup // 声明sync.WaitGroup
	wg.Add(1)             // 主函数中定义WaitGroup队列的长度
	go func() {
		demoTest()
		defer wg.Done() // 子协程中，函数最后调用，相当于WaitGroup队列-1
	}()
	wg.Wait() // 主函数中，函数最后调用，相当于等待WaitGroup队列为0
	fmt.Println("程序执行完成")
}
```

![avatar](http://type.zimopy.com/usr/uploads/2023/03/496577956.png)

### sync.Cond![1678094324525.png](http://type.zimopy.com/usr/uploads/2023/03/381080581.png)

实现只有一个协程的等待，完成后并通知下一个协程开始工作

```
package main

import (
   "fmt"
   "sync"
)

func demoTest() {
   fmt.Println("demoTest函数")
}

func main() {
   fmt.Println("main函数")
   var locker = new(sync.Mutex)
   var cond = sync.NewCond(locker)
   done := false
   cond.L.Lock()

go func() {
   	demoTest()
   	fmt.Println("demoTest函数执行完成")
   	done = true
   	cond.Signal()
   }()
   fmt.Println("wait")
   if !done {
   	cond.Wait()
   	cond.L.Unlock()
   }
   fmt.Println("程序执行完成")
}

```

![avatar](http://type.zimopy.com/usr/uploads/2023/03/381080581.png)

[参考文章](https://juejin.cn/post/7000570207185944589)

### channel![1678095192212.png](http://type.zimopy.com/usr/uploads/2023/03/62242836.png)

```
package main

import (
   "fmt"
)

func demoTest() {
   fmt.Println("demoTest函数")
}

func main() {
   fmt.Println("main函数")
   ch := make(chan bool, 1)
   go func(chp chan<- bool) {
   	defer close(chp)
   	demoTest()
   	fmt.Println("demoTest函数完成")
   	chp <- true
   }(ch)
   fmt.Println("wait")
   fmt.Println("channel结果", <-ch)
   fmt.Println("程序执行完成")
}

```

![1678167877907.png](http://type.zimopy.com/usr/uploads/2023/03/58794194.png)
![请输入图片描述](http://type.zimopy.com/usr/uploads/2023/03/62242836.png)

### errgroup

记录错误

```
package main

import (
   "fmt"
   "golang.org/x/sync/errgroup"
)

func demoOneTest() error {
   fmt.Println("demoOneTest函数")
   return fmt.Errorf("demo1Test error")
}

func demoTwoTest() error {
   fmt.Println("demoTwoTest函数")
   return fmt.Errorf("demo2Test error")
}

func main() {
   fmt.Println("main函数")
   eg := errgroup.Group{}

// 开启一个协程
   eg.Go(demoOneTest)

eg.Go(demoTwoTest)

// 等待所有的协程完毕后，进行下面的逻辑，并记录协程的错误
   if err := eg.Wait(); err != nil {
   	fmt.Printf("发生错误：%s\n", err.Error())
   }
   fmt.Println("程序执行完成")
}
```

![请输入图片描述](http://type.zimopy.com/usr/uploads/2023/03/58794194.png)

一个协程出错，其他协程终止

```
package main

import (
   "context"
   "fmt"
   "golang.org/x/sync/errgroup"
   "log"
   "net/http"
   "os"
   "os/signal"
   "syscall"
   "time"
)

func main() {
   g, ctx := errgroup.WithContext(context.Background())

mux := http.NewServeMux()
   mux.HandleFunc("/ping", func(w http.ResponseWriter, r *http.Request) {
   	w.Write([]byte("pong"))
   })

// 模拟单个服务错误退出
   serverOut := make(chan struct{})
   mux.HandleFunc("/shutdown", func(w http.ResponseWriter, r *http.Request) {
   	serverOut <- struct{}{}
   })

server := http.Server{
   	Handler: mux,
   	Addr:    ":8080",
   }

// g1
   // g1 退出了所有的协程都能退出么？
   // g1 退出后, context 将不再阻塞，g2, g3 都会随之退出
   // 然后 main 函数中的 g.Wait() 退出，所有协程都会退出
   g.Go(func() error {
   	return server.ListenAndServe()
   })

// g2
   // g2 退出了所有的协程都能退出么？
   // g2 退出时，调用了 shutdown，g1 会退出
   // g2 退出后, context 将不再阻塞，g3 会随之退出
   // 然后 main 函数中的 g.Wait() 退出，所有协程都会退出
   g.Go(func() error {
   	select {
   	case <-ctx.Done():
   		log.Println("errgroup exit...")
   	case <-serverOut:
   		log.Println("server will out...")
   	}

timeoutCtx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
   	// 这里不是必须的，但是如果使用 _ 的话静态扫描工具会报错，加上也无伤大雅
   	defer cancel()

log.Println("shutting down server...")
   	return server.Shutdown(timeoutCtx)
   })

// g3
   // g3 捕获到 os 退出信号将会退出
   // g3 退出了所有的协程都能退出么？
   // g3 退出后, context 将不再阻塞，g2 会随之退出
   // g2 退出时，调用了 shutdown，g1 会退出
   // 然后 main 函数中的 g.Wait() 退出，所有协程都会退出
   g.Go(func() error {
   	quit := make(chan os.Signal, 0)
   	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)

select {
   	case <-ctx.Done():
   		return ctx.Err()
   	case sig := <-quit:
   		return fmt.Errorf("get os signal: %v", sig)
   	}
   })

fmt.Printf("errgroup exiting: %+v\n", g.Wait())
}
```

运行后，按`ctrl+c`终止程序，输出结果为：

![1678170132424.png](http://type.zimopy.com/usr/uploads/2023/03/4228994291.png)

## 四、goroutine控制

### goroutine崩溃处理

```
package main

import (
	"fmt"
	"sync"
)

func demoTest() {
	defer func() { // 在panic前声明defer，能捕获异常
		if err := recover(); err != nil {
			fmt.Println("恢复\n", err)
		}
	}()
	fmt.Println("demoTest函数")
	panic("崩溃")
}

func main() {
	wg := sync.WaitGroup{}
	fmt.Println("main函数")
	wg.Add(1)
	go func() {
		defer wg.Done()
		demoTest()
	}()
	wg.Wait()
	fmt.Println("执行完成")
}
```

![1678176713680.png](http://type.zimopy.com/usr/uploads/2023/03/2206573414.png)

> **如果在协程内执行其它函数时，为了保证不崩溃，安全的做法是，提前声明defer recover函数**

### goroutine超时控制

```
package main

import (
	"context"
	"fmt"
	"sync"
	"time"
)

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 second")
	case <-done:
		fmt.Println("done")
	}
}

func main() {
	fmt.Println("main")
	ctx := context.Background()
	wg := sync.WaitGroup{}
	wg.Add(1)
	go Do(ctx, &wg)
	wg.Wait()
	fmt.Println("finish")
}
```

![1678179206955.png](http://type.zimopy.com/usr/uploads/2023/03/2026336057.png)

最后修改：2023 年 03 月 08 日

如果觉得我的文章对你有用，请随意赞赏

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

评论 *

私密评论

名称 *

🎲

邮箱

地址

huoyu1
真的很需要
欣
很牛逼|´・ω・)ノ
hhh
真棒
Hongjia
https://blog.dingtone.me/zh/rec...
Hongjia
https://5sim.net/zh使用该网站可以最低1 卢布充值

goroutine的使用

欣七天 • 2023 年 03 月 08 日

# goroutine的使用

## 一、简介

GO是并发语言，不是并行语言。

goroutine中没有返回值，一般是通过channel进行goroutine之间的通信的。

## 二、goroutine调度原理

### 调度器架构

Go的调度器从最开始的单线程经过不断的改进、优化，发展到现在的GMP模型，在GMP模型中有三个重要的结构：

### 调度策略

#### 复用线程

##### 利用多核CPU并行

`GOMAXPROCS`设置P的数量，最多有`GOMAXPROCS`个线程分布在多个CPU核心上运行。`runtime.GOMAXPROCS(N)`修改，N表示设置的个数

#### 抢占

一个goroutine最多占用CPU10ms，防止其他goroutine等待太久得不到执行被“饿死”。

#### 全局G队列

全局G队列是有互斥锁保护的，访问需要竞争锁，新的调度器将其功能弱化了，当M执行work stealing从其他P窃取不到G时，才会去全局G队列获取G。

## 三、goroutine应用

### 基础应用

```
package main

import "fmt"

func demoTest() {
	for i := 0; i < 500; i++ {
		fmt.Println("goroutine输出结果：", i)
	}
}

func main() {
	go demoTest()
	for i := 1; i < 500; i++ {
		fmt.Println("main输出结果：", i)
	}
}
```

![avatar](http://type.zimopy.com/usr/uploads/2023/03/3602092283.png)

### sync.WaitGroup![1678092824227.png](http://type.zimopy.com/usr/uploads/2023/03/496577956.png)

实现主线程不退出，等待协程组的完成

```
package main

import (
	"fmt"
	"sync"
)

func demoTest() {
	fmt.Println("demoTest函数")
}

![avatar](http://type.zimopy.com/usr/uploads/2023/03/496577956.png)

### sync.Cond![1678094324525.png](http://type.zimopy.com/usr/uploads/2023/03/381080581.png)

实现只有一个协程的等待，完成后并通知下一个协程开始工作

```
package main

import (
   "fmt"
   "sync"
)

func demoTest() {
   fmt.Println("demoTest函数")
}

func main() {
   fmt.Println("main函数")
   var locker = new(sync.Mutex)
   var cond = sync.NewCond(locker)
   done := false
   cond.L.Lock()

```

![avatar](http://type.zimopy.com/usr/uploads/2023/03/381080581.png)

[参考文章](https://juejin.cn/post/7000570207185944589)

### channel![1678095192212.png](http://type.zimopy.com/usr/uploads/2023/03/62242836.png)

```
package main

import (
   "fmt"
)

func demoTest() {
   fmt.Println("demoTest函数")
}

```

![1678167877907.png](http://type.zimopy.com/usr/uploads/2023/03/58794194.png)
![请输入图片描述](http://type.zimopy.com/usr/uploads/2023/03/62242836.png)

### errgroup

记录错误

```
package main

import (
   "fmt"
   "golang.org/x/sync/errgroup"
)

func demoOneTest() error {
   fmt.Println("demoOneTest函数")
   return fmt.Errorf("demo1Test error")
}

func demoTwoTest() error {
   fmt.Println("demoTwoTest函数")
   return fmt.Errorf("demo2Test error")
}

func main() {
   fmt.Println("main函数")
   eg := errgroup.Group{}

// 开启一个协程
   eg.Go(demoOneTest)

eg.Go(demoTwoTest)

![请输入图片描述](http://type.zimopy.com/usr/uploads/2023/03/58794194.png)

一个协程出错，其他协程终止

```
package main

import (
   "context"
   "fmt"
   "golang.org/x/sync/errgroup"
   "log"
   "net/http"
   "os"
   "os/signal"
   "syscall"
   "time"
)

func main() {
   g, ctx := errgroup.WithContext(context.Background())

mux := http.NewServeMux()
   mux.HandleFunc("/ping", func(w http.ResponseWriter, r *http.Request) {
   	w.Write([]byte("pong"))
   })

// 模拟单个服务错误退出
   serverOut := make(chan struct{})
   mux.HandleFunc("/shutdown", func(w http.ResponseWriter, r *http.Request) {
   	serverOut <- struct{}{}
   })

server := http.Server{
   	Handler: mux,
   	Addr:    ":8080",
   }

log.Println("shutting down server...")
   	return server.Shutdown(timeoutCtx)
   })

select {
   	case <-ctx.Done():
   		return ctx.Err()
   	case sig := <-quit:
   		return fmt.Errorf("get os signal: %v", sig)
   	}
   })

fmt.Printf("errgroup exiting: %+v\n", g.Wait())
}
```

运行后，按`ctrl+c`终止程序，输出结果为：

![1678170132424.png](http://type.zimopy.com/usr/uploads/2023/03/4228994291.png)

## 四、goroutine控制

### goroutine崩溃处理

```
package main

import (
	"fmt"
	"sync"
)

func main() {
	wg := sync.WaitGroup{}
	fmt.Println("main函数")
	wg.Add(1)
	go func() {
		defer wg.Done()
		demoTest()
	}()
	wg.Wait()
	fmt.Println("执行完成")
}
```

![1678176713680.png](http://type.zimopy.com/usr/uploads/2023/03/2206573414.png)

> **如果在协程内执行其它函数时，为了保证不崩溃，安全的做法是，提前声明defer recover函数**

### goroutine超时控制

```
package main

import (
	"context"
	"fmt"
	"sync"
	"time"
)

func Do(ctx context.Context, wg *sync.WaitGroup) {
	ctx, cancle := context.WithTimeout(ctx, time.Second*2)
	defer func() {
		cancle()
		wg.Done()
	}()

select {
	case <-ctx.Done():
		fmt.Printf("timeout,err:%v\n", ctx.Err())
	case <-time.After(3 * time.Second):
		fmt.Printf("after 1 second")
	case <-done:
		fmt.Println("done")
	}
}

func main() {
	fmt.Println("main")
	ctx := context.Background()
	wg := sync.WaitGroup{}
	wg.Add(1)
	go Do(ctx, &wg)
	wg.Wait()
	fmt.Println("finish")
}
```

![1678179206955.png](http://type.zimopy.com/usr/uploads/2023/03/2026336057.png)

goroutine的使用

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

速注册OpenAi（ChatGPT），国内也可以

Frida 代码自动补全

ubuntu 实现内网穿透

最新Fiddler Web Debugger v5.0 20202.18177中文版

windows一键启动雷电模拟器的frida-server

open-ssl生成证书

B站弹幕获取方式一

Mac 安装使用 Redis

Android Studio模拟器安装Magisk

mac 使用的代理，终端不可直接使用，配置一下

goroutine的使用

发表评论 取消回复 使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

goroutine的使用

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款