grpool goroutine池协程管理

目录
  • 前言
  • 名词概念
  • 使用示例
  • 踩坑之旅
    • 常犯的错误
  • 分析原因
    • 使用grpool
    • 错误代码
    • 正确代码
  • 总结

前言

goroutine协程非常轻量级，这也是为什么go支持高并发，但是goroutine频繁创建销毁对GC的压力比较大。

grpool的作用就是复用goroutine，减少频繁创建销毁的性能消耗。

名词概念

Pool: goroutine池，用于管理若干可复用的goroutine协程资源

Worker: 池对象中参与任务执行的goroutine，一个worker可以执行若干个job，直到队列中再无等待的job

Job：添加到池对象的任务队列中等待执行的任务，是一个func()方法，一个job同时只能被一个worker获取并执行。

使用示例

使用默认的协程池，限制100个协程执行1000个任务

pool.Size() 获得当前工作的协程数量

pool.Jobs() 获得当前池中待处理的任务数量

package main
import (
   "fmt"
   "github.com/gogf/gf/os/grpool"
   "github.com/gogf/gf/os/gtimer"
   "sync"
   "time"
)
func main() {
   pool := grpool.New(100)
   //添加1千个任务
   for i := 0; i < 1000; i++ {
      _ = pool.Add(job)
   }
   fmt.Println("worker:", pool.Size()) //当前工作的协程数量
   fmt.Println("jobs:", pool.Jobs())   //当前池中待处理的任务数量

   gtimer.SetInterval(time.Second, func() {
      fmt.Println("worker:", pool.Size()) //当前工作的协程数
      fmt.Println("jobs:", pool.Jobs())   //当前池中待处理的任务数
   })
   //阻止进程结束
   select {}
}
//任务方法
func job() {
   time.Sleep(time.Second)
}

打印结果：

是不是灰常简单~

踩坑之旅

一个简单的场景，请使用协程打印0~9。

常犯的错误

大家看下面的代码有没有问题，请预测一下打印结果。

wg := sync.WaitGroup{}
for i := 0; i < 9; i++ {
   wg.Add(1)
   go func() {
      fmt.Println(i)
      wg.Done()
   }()
}
wg.Wait()

不用着急看答案

猜一下打印结果是什么

打印结果：

分析原因

对于异步线程/协程来讲，函数进行异步执行注册时，该函数并未真正开始执行(注册时只在goroutine的栈中保存了变量i的内存地址)，而一旦开始执行时函数才会去读取变量i的值，而这个时候变量i的值已经自增到了9。

正确写法：

wg := sync.WaitGroup{}
for i := 0; i < 9; i++ {
   wg.Add(1)
   go func(v int) {
      fmt.Println(v)
      wg.Done()
   }(i)
}
wg.Wait()

打印结果：

使用grpool

使用grpool和使用go一样，都需要把当前变量i的值赋值给一个不会改变的临时变量，在函数中使用该临时变量而不是直接使用变量i。

错误代码

wg := sync.WaitGroup{}
for i := 0; i < 9; i++ {
   wg.Add(1)
   _ = grpool.Add(func() {
      fmt.Println(i) //打印结果都是9
      wg.Done()
   })
}
wg.Wait()

打印结果：

正确代码

wg := sync.WaitGroup{}
for i := 0; i < 9; i++ {
   wg.Add(1)
   v := i //grpoll.add() 的参数只能是不带参数的匿名函数 因此只能以设置临时变量的方式赋值
   _ = grpool.Add(func() {
      fmt.Println(v)
      wg.Done()
   })
}
wg.Wait()

打印结果：

总结

通过这篇文章我们了解到：grpool的作用就是复用goroutine，减少频繁创建销毁的性能消耗。也了解到使用协程容易犯的错误，以及用临时变量的方式来解决问题。

说句题外话：grpool的基础概念：Pool、Worke、Job 和我之前设计的派单系统简直一模一样。

到此这篇关于grpool goroutine池协程管理的文章就介绍到这了,更多相关grpool goroutine池 内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

赞 (0)

相关推荐

  • Go并发编程之goroutine使用正确方法

    Go并发编程之goroutine使用正确方法

    目录 1. 对创建的gorouting负载 1.1 不要创建一个你不知道何时退出的 goroutine 1.2 不要帮别人做选择 1.3 不要作为一个旁观者 1.4 不要创建不知道什么时候退出的 goroutine 1.5 不要创建都无法退出的 goroutine 1.6 确保创建出的goroutine工作已经完成 2. 总结 3. 参考 并发(concurrency): 指在同一时刻只能有一条指令执行,但多个进程指令被快速的轮换执行,使得在宏观上具有多个进程同时执行的效果,但在微观上并不是同时

  • Go语言中的并发goroutine底层原理

    Go语言中的并发goroutine底层原理

    目录 一.基本概念 ①并发.并行区分 ②从用户态线程,内核态线程阐述go与java并发的优劣 ②高并发为什么是Go语言强项? ③Go语言实现高并发底层GMP模型原理解析 二.上代码学会Go语言并发 ①.开启一个简单的线程 ②.动态的关闭线程 一.基本概念 ①并发.并行区分 1.概念 并发:同一时间段内一个对象执行多个任务,充分利用时间 并行:同一时刻,多个对象执行多个任务 2.图解 类似于超市柜台结账,并行是多个柜台结多个队列,在计算机中是多核cpu处理多个go语言开启的线程,并发是一个柜台结账

  • Go语言七篇入门教程四通道及Goroutine

    Go语言七篇入门教程四通道及Goroutine

    目录 1. 前言 2. 通道简介 2.1 声明 2.1 读写 2.3 通道详解 2.3.1 例子 2.3.2 死锁 2.3.3 关闭通道 2.3.4 缓冲区 2.3.5 通道的长度和容量 2.3.6 单向通道 2.3.7 Select 2.3.8 default case 块 2.3.9 空 select 2.3.10 Deadlock 2.3.11 nil通道 2.4 多协程协同工作 2.5 WaitGroup 2.5.1 简介 2.5.2工作池 2.5.3 Mutex 3. 结语 如何学习G

  • Go语言死锁与goroutine泄露问题的解决

    目录 什么时候会导致死锁 发送单个值时的死锁 多个值发送的死锁 解决多值发送死锁 应该先发送还是先接收 goroutine 泄漏 如何发现泄露 小结 什么时候会导致死锁 在计算机组成原理里说过 死锁有三个必要条件他们分别是 循环等待.资源共享.非抢占式,在并发中出现通道死锁只有两种情况: 数据要发送,但是没有人接收 数据要接收,但是没有人发送 发送单个值时的死锁 牢记这两点问题就很清晰了,复习下之前的例子,会死锁 a := make(chan int) a <- 1 //将数据写入channel

  • 关于golang利用channel和goroutine完成统计素数的思路

    关于golang利用channel和goroutine完成统计素数的思路

    1. 需求 要求统计1-200000的数字中,哪些是素数?这个问题在本章开篇就提出来了,可以使用goroutine和channel来完成 2.分析思路 传统的方法,就是使用一个循环,循环的判断各个数是不是素数[ok] 使用并发/并行的方式,将统计素数的任务分配给多个(x个)goroutine去完成,完成任务时间短 分析思路图:  代码实现: package main import ( "fmt" "time" ) // 需求: // 要求统计1-200000的数字,

  • Go并发的方法之goroutine模型与调度策略

    Go并发的方法之goroutine模型与调度策略

    目录 单进程操作系统 多线程/多进程操作系统 1:N模型 M:N模型 goroutine goroutine早期调度器 GMP 调度器设计策略 复用线程 并行 抢占 全局队列 学习刘丹冰<8小时转职golang工程师>,本节都是原理 单进程操作系统 早期的单进程操作系统,可以理解为只有一个时间轴,CPU顺序执行每一个进程/线程,这种顺序执行的方式,CPU同一时间智能处理一个指令,一个任务一个任务去处理 这样就会导致进程阻塞的话,CPU就会卡在当前进程,一直在等待,CPU就会浪费 多线程/多进程

  • grpool goroutine池协程管理

    grpool goroutine池协程管理

    目录 前言 名词概念 使用示例 踩坑之旅 常犯的错误 分析原因 使用grpool 错误代码 正确代码 总结 前言 goroutine协程非常轻量级,这也是为什么go支持高并发,但是goroutine频繁创建销毁对GC的压力比较大. grpool的作用就是复用goroutine,减少频繁创建销毁的性能消耗. 名词概念 Pool: goroutine池,用于管理若干可复用的goroutine协程资源 Worker: 池对象中参与任务执行的goroutine,一个worker可以执行若干个job,直到

  • Golang协程池gopool设计与实现

    目录 Goroutine 协程池 gopool 核心实现 Pool Task Worker 整体来看 三个角色的定位 使用 sync.Pool 进行性能优化 Goroutine Goroutine 是 Golang 提供的一种轻量级线程,我们通常称之为「协程」,相比较线程,创建一个协程的成本是很低的.所以你会经常看到 Golang 开发的应用出现上千个协程并发的场景. Goroutine 的优势: 与线程相比,Goroutines 成本很低. 它们的堆栈大小只有几 kb,堆栈可以根据应用程序的需

  • golang 40行代码实现通用协程池

    代码仓库 goroutine-pool golang的协程管理 golang协程机制很方便的解决了并发编程的问题,但是协程并不是没有开销的,所以也需要适当限制一下数量. 不使用协程池的代码(示例代码使用chan实现,代码略啰嗦) func (p *converter) upload(bytes [][]byte) ([]string, error) { ch := make(chan struct{}, 4) wg := &sync.WaitGroup{} wg.Add(len(bytes))

  • Golang 之协程的用法讲解

    一.Golang 线程和协程的区别 备注:需要区分进程.线程(内核级线程).协程(用户级线程)三个概念. 进程.线程 和 协程 之间概念的区别 对于 进程.线程,都是有内核进行调度,有 CPU 时间片的概念,进行 抢占式调度(有多种调度算法) 对于 协程(用户级线程),这是对内核透明的,也就是系统并不知道有协程的存在,是完全由用户自己的程序进行调度的,因为是由用户程序自己控制,那么就很难像抢占式调度那样做到强制的 CPU 控制权切换到其他进程/线程,通常只能进行 协作式调度,需要协程自己主动把控

  • 一篇文章带你了解Python的进程,线程和协程

    目录 线程 线程锁 threading.RLock和threading.Lock 的区别 threading.Event threading.Condition queue 队列 生产者消费者模型 进程 Server process 进程池 协程 总结 线程 Threading用于提供线程相关的操作.线程是应用程序中工作的最小单元,它被包含在进程之中,是进程中的实际运作单位.一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务. threading 模

  • Go 并发实现协程同步的多种解决方法

    go 简洁的并发 多核处理器越来越普及.有没有一种简单的办法,能够让我们写的软件释放多核的威力?是有的.随着Golang, Erlang, Scala等为并发设计的程序语言的兴起,新的并发模式逐渐清晰.正如过程式编程和面向对象一样,一个好的编程模式有一个极其简洁的内核,还有在此之上丰富的外延.可以解决现实世界中各种各样的问题.本文以GO语言为例,解释其中内核.外延. 前言 Java 中有一系列的线程同步的方法,go 里面有 goroutine(协程),先看下下面的代码执行的结果是什么呢? pac

  • Golang控制协程执行顺序方法详解

    目录 循环控制 通道控制 互斥锁 async.Mutex 在 Go 里面的协程执行实际上默认是没有严格的先后顺序的.由于 Go 语言 GPM 模型的设计理念,真正执行实际工作的实际上是 GPM 中的 M(machine) 执行器,而我们的协程任务 G(goroutine) 协程需要被 P(produce) 关联到某个 M 上才能被执行.而每一个 P 都有一个私有队列,除此之外所有的 P 还共用一个公共队列.因此当我们创建了一个协程之后,并不是立即执行,而是进入队列等待被分配,且不同队列之间没有顺

  • GO实现协程池管理的方法

    使用channel实现协程池 通过 Channel 实现 Goroutine Pool,缺点是会造成协程的频繁开辟和注销,但好在简单灵活通用. package main import ( "fmt" "io/ioutil" "net/http" "sync" ) // Pool goroutine Pool type Pool struct { queue chan int wg *sync.WaitGroup } // Ne

  • Go简单实现协程池的实现示例

    Go简单实现协程池的实现示例

    目录 MPG模型 通道的特性 首先就是进程.线程.协程讲解老三样. 进程: 本质上是一个独立执行的程序,进程是操作系统进行资源分配和调度的基本概念,操作系统进行资源分配和调度的一个独立单位. 线程: 是操作系统能够进行运算调度的最小单位.它被包含在进程之中,是进程中的实际运作单位.一个进程中可以并发多个线程,每条线程执行不同的任务,切换受系统控制. 协程:  又称为微线程,是一种用户态的轻量级线程,协程不像线程和进程需要进行系统内核上的上下文切换,协程的上下文切换是由用户自己决定的,有自己的上下

  • golang协程池设计详解

    Why Pool go自从出生就身带"高并发"的标签,其并发编程就是由groutine实现的,因其消耗资源低,性能高效,开发成本低的特性而被广泛应用到各种场景,例如服务端开发中使用的HTTP服务,在golang net/http包中,每一个被监听到的tcp链接都是由一个groutine去完成处理其上下文的,由此使得其拥有极其优秀的并发量吞吐量 for { // 监听tcp rw, e := l.Accept() if e != nil { ....... } tempDelay = 0

随机推荐