Goroutine池实现

一.为什么要实现Goroutine池

  • 即便每个goroutine只分配4KB的内存,但如果是恐怖如斯的数量,聚少成多,内存会占用过高。
  • 会对GC造成极大的负担,首先GC会在回收goroutine上消耗性能,其次GC本身也是goroutine,内存吃紧的状态下连GC的调度都会出现问题。
  • 提高响应速度,减少创建协程的时间。
  • 更好的管理协程,控制最大并发数量,定期回收。

二.协程池的设计思路

  1. 启动服务的时候初始化一个Goroutine Pool,这个协程池维护了任务的管道和worker。
  2. 外部将请求投递到Goroutine Pool,Goroutine Pool的操作是:判断当前运行的worker是否已经超过Pool的容量,如果超过就将请求放到任务管道中直到运行的worker将管道中的任务执行;如果没有超过就新开一个worker处理。

三.协程池的实现细节

3.1 任务投递

func (rp *RoutinePool) Execute(task Runable) bool {
	rp.mainLock.RLock()
	if rp.closed {
		rp.mainLock.RUnlock()
		return false
	}

	if rp.WorkerSize < rp.NormalWorkerSize {

		worker := NewWorker(rp.TaskQueue, rp.ExpireInterval, true, rp.workerDestroyChan, rp.closeChan)
		worker.Start()
		rp.WorkerSize++

	} else if (rp.WorkerSize < rp.MaxWorkerSize) && (len(rp.TaskQueue) >= int(rp.TaskQueueSize)) {

		worker := NewWorker(rp.TaskQueue, rp.ExpireInterval, false, rp.workerDestroyChan, rp.closeChan)
		worker.Start()
		rp.WorkerSize++
	}
	rp.mainLock.RUnlock()

	timer := time.NewTimer(rp.WaitInterval)
	defer timer.Stop()

	select {
	case rp.TaskQueue <- task:
		return true
	case <-timer.C:
		return false
	}

	return false
}

3.2 任务执行

func (w *Worker) Start() {

	go func() {
		ticker := time.NewTicker(time.Second)
		defer ticker.Stop()

		for {
			select {
			case task := <-w.taskQueue:
				if task == nil {
					continue
				}

				//do task
				task.Run()
				//update lastTime
				w.lastTime = time.Now()

			case <-ticker.C:
				if (!w.reservedFlag) && (time.Now().Sub(w.lastTime) > w.expireInterval) {

					w.destroyChan <- true
					return
				}

			case <-w.closeChan:
				return
			}
		}
	}()
}

四.待改进

  • 执行函数失效应该再次投递此任务,等到重复执行限制次数后向上层抛出error。
  • 最好能查看任务的状态,如果任务没有在执行支持任务的取消。

 

  • 1
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
实现一个 goroutine 的一般步骤如下: 1. 定义一个任务队列,用于存储待执行的任务; 2. 定义一个 worker ,用于存储 goroutine; 3. worker 中的 goroutine 从任务队列中获取任务,执行任务; 4. 当任务队列为空时,worker 中的 goroutine 进入休眠状态; 5. 当新任务到达时,唤醒一个休眠的 goroutine,让其执行任务。 下面给出一个可能的实现方案: ```go type Job func() type Pool struct { jobChan chan Job workers []*Worker } type Worker struct { pool *Pool taskChan chan Job } func NewWorker(pool *Pool) *Worker { return &Worker{ pool: pool, taskChan: make(chan Job), } } func (w *Worker) Start() { go func() { for { w.pool.workerChan <- w task := <- w.taskChan task() } }() } func NewPool(numWorkers int) *Pool { pool := &Pool{ jobChan: make(chan Job), workers: make([]*Worker, numWorkers), } for i := 0; i < numWorkers; i++ { worker := NewWorker(pool) pool.workers[i] = worker worker.Start() } go pool.dispatch() return pool } func (p *Pool) dispatch() { for { select { case job := <- p.jobChan: worker := <- p.workerChan worker.taskChan <- job } } } func (p *Pool) AddJob(job Job) { p.jobChan <- job } ``` 以上代码实现了一个 goroutine 的基本功能。在 `NewPool()` 函数中创建了指定数量的 worker,并启动了它们。在 `dispatch()` 函数中,监听了任务队列 `jobChan`,当有新任务到来时,从 worker 中获取一个 worker,将任务分配给它执行。在 `AddJob()` 函数中,向任务队列中添加一个任务。 对于请求量大于消费能力的情况,可以考虑以下几种方案: 1. 增加 worker 数量,提高消费能力; 2. 增加任务队列长度,缓解请求量过大的压力; 3. 采用限流策略,例如令牌桶算法、漏桶算法等,限制请求的速率; 4. 根据负载情况,动态调整 worker 数量,实现自适应扩缩容。 以上方案可以根据实际情况选择合适的方案进行实现

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值