golang轻量级Goroutine线程池管理插件库grpool的使用

golang轻量级Goroutine线程池管理插件库grpool的使用

概述

grpool是一个轻量级的Goroutine线程池管理库。客户端可以提交作业，调度器会获取作业并将其发送给第一个可用的工作线程。当工作线程完成作业处理后，会返回到工作线程池中。

工作线程数量和作业队列大小是可配置的。

安装

go get github.com/ivpusic/grpool

简单示例

package main

import (
  "fmt"
  "runtime"
  "time"

  "github.com/ivpusic/grpool"
)

func main() {
  // 设置工作线程数量为100，作业队列大小为50
  pool := grpool.NewPool(100, 50)

  // 释放池使用的资源
  defer pool.Release()

  // 向池提交一个或多个作业
  for i := 0; i < 10; i++ {
    count := i

    pool.JobQueue <- func() {
      fmt.Printf("I am worker! Number %d\n", count)
    }
  }

  // 等待作业完成
  time.Sleep(1 * time.Second)
}

等待作业完成的示例

package main

import (
  "fmt"
  "runtime"

  "github.com/ivpusic/grpool"
)

func main() {
  // 设置工作线程数量为100，作业队列大小为50
  pool := grpool.NewPool(100, 50)
  defer pool.Release()

  // 设置需要等待的作业数量
  pool.WaitCount(10)

  // 向池提交一个或多个作业
  for i := 0; i < 10; i++ {
    count := i

    pool.JobQueue <- func() {
      // 标记作业完成
      defer pool.JobDone()

      fmt.Printf("hello %d\n", count)
    }
  }

  // 等待所有作业完成
  pool.WaitAll()
}

许可证

MIT


更多关于golang轻量级Goroutine线程池管理插件库grpool的使用的实战教程也可以访问 https://www.itying.com/category-94-b0.html

1 回复

更多关于golang轻量级Goroutine线程池管理插件库grpool的使用的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


grpool - Golang轻量级Goroutine线程池管理库

grpool是一个轻量级的Goroutine线程池管理库，它可以帮助你控制并发执行的Goroutine数量，避免无限制地创建Goroutine导致资源耗尽的问题。

主要特性

  1. 限制最大并发Goroutine数量
  2. 任务队列管理
  3. 简单的API设计
  4. 轻量级实现

安装

go get github.com/ivpusic/grpool

基本使用示例

package main

import (
	"fmt"
	"github.com/ivpusic/grpool"
	"time"
)

func main() {
	// 创建一个包含10个工作Goroutine的池
	// 队列大小为100
	pool := grpool.NewPool(10, 100)
	
	// 确保在程序结束时关闭池
	defer pool.Release()
	
	// 提交任务到池中
	for i := 0; i < 20; i++ {
		count := i
		pool.JobQueue <- func() {
			// 模拟耗时任务
			time.Sleep(1 * time.Second)
			fmt.Printf("任务 %d 由Goroutine执行\n", count)
		}
	}
	
	// 等待所有任务完成
	pool.WaitAll()
}

高级功能示例

1. 带返回值的任务

package main

import (
	"fmt"
	"github.com/ivpusic/grpool"
)

func main() {
	pool := grpool.NewPool(5, 50)
	defer pool.Release()
	
	results := make(chan int, 10)
	
	for i := 0; i < 10; i++ {
		num := i
		pool.JobQueue <- func() {
			// 模拟计算
			result := num * 2
			results <- result
		}
	}
	
	// 收集结果
	for i := 0; i < 10; i++ {
		fmt.Println("结果:", <-results)
	}
}

2. 错误处理

package main

import (
	"errors"
	"fmt"
	"github.com/ivpusic/grpool"
)

func main() {
	pool := grpool.NewPool(3, 30)
	defer pool.Release()
	
	errChan := make(chan error, 5)
	
	for i := 0; i < 5; i++ {
		pool.JobQueue <- func() {
			// 模拟可能出错的任务
			if i%2 == 0 {
				errChan <- errors.New("偶数任务出错")
				return
			}
			fmt.Println("任务成功执行")
		}
	}
	
	// 检查错误
	for i := 0; i < 5; i++ {
		if err := <-errChan; err != nil {
			fmt.Println("错误:", err)
		}
	}
}

性能考虑

  1. 池大小选择：根据你的CPU核心数和任务类型选择适当的池大小。IO密集型任务可以设置更大的池。
  2. 队列大小：确保队列足够大以避免阻塞，但也不要太大导致内存消耗过高。
  3. 任务粒度：任务不应该太细粒度，否则管理开销可能超过并行带来的好处。

替代方案比较

  1. 原生Goroutine：简单但无法控制并发数量
  2. sync.WaitGroup：只能等待完成，无法控制并发
  3. ants库：更复杂的特性但更大的内存占用
  4. grpool：轻量级，适合简单场景

最佳实践

  1. 在服务端程序中始终使用线程池来控制并发
  2. 为不同类型的任务创建不同的池
  3. 监控池的使用情况，调整大小
  4. 确保任务正确处理panic，避免影响整个池

总结

grpool是一个简单易用的Goroutine池实现，适合需要控制并发数量的场景。它的轻量级特性使其成为许多应用的理想选择，特别是当你不需更复杂的特性时。

对于更高级的需求，你可能需要查看其他库如ants或tunny，但对于大多数基本用例，grpool提供了足够的功能够用且易于使用。

回到顶部