Golang高效管理Goroutine并发池插件库tunny使用指南

什么是tunny

tunny是一个轻量级的Goroutine池实现，它可以帮助开发者高效管理并发任务，避免频繁创建和销毁Goroutine带来的性能开销。tunny的主要特点包括：

• 固定数量的工作Goroutine
• 任务队列机制
• 支持超时控制
• 简单的API设计

tunny基本使用

安装tunny

go get github.com/Jeffail/tunny

基本示例

package main

import (
	"fmt"
	"time"
	"github.com/Jeffail/tunny"
)

func main() {
	// 创建一个包含3个工作Goroutine的池
	pool := tunny.NewFunc(3, func(payload interface{}) interface{} {
		// 这里是工作函数
		n := payload.(int)
		result := n * n
		fmt.Printf("处理 %d => %d\n", n, result)
		time.Sleep(1 * time.Second) // 模拟耗时操作
		return result
	})
	defer pool.Close()

	// 提交任务到池中
	for i := 1; i <= 10; i++ {
		go func(n int) {
			// 同步调用
			result, err := pool.ProcessTimed(n, 2*time.Second)
			if err != nil {
				fmt.Printf("任务 %d 处理超时: %v\n", n, err)
				return
			}
			fmt.Printf("任务 %d 完成, 结果: %d\n", n, result.(int))
		}(i)
	}

	// 等待所有任务完成
	time.Sleep(5 * time.Second)
}

tunny高级特性

1. 动态调整池大小

pool.SetSize(5) // 将池大小调整为5

2. 异步处理

go func() {
    result := pool.Process(10)
    fmt.Println(result)
}()

3. 超时控制

result, err := pool.ProcessTimed(5, 1*time.Second)
if err != nil {
    fmt.Println("处理超时:", err)
}

4. 获取池状态

queuedJobs := pool.QueueLength() // 获取队列中等待的任务数

实际应用示例

处理HTTP请求

package main

import (
	"fmt"
	"net/http"
	"sync"
	"github.com/Jeffail/tunny"
)

func main() {
	// 创建处理池
	pool := tunny.NewFunc(10, func(payload interface{}) interface{} {
		req := payload.(*http.Request)
		// 模拟处理请求
		time.Sleep(500 * time.Millisecond)
		return fmt.Sprintf("已处理请求: %s", req.URL.Path)
	})
	defer pool.Close()

	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		// 使用池处理请求
		result, err := pool.ProcessTimed(r, 1*time.Second)
		if err != nil {
			http.Error(w, "处理超时", http.StatusRequestTimeout)
			return
		}
		fmt.Fprintln(w, result)
	})

	fmt.Println("服务器启动在 :8080")
	http.ListenAndServe(":8080", nil)
}

批量处理数据

package main

import (
	"fmt"
	"sync"
	"time"
	"github.com/Jeffail/tunny"
)

func main() {
	// 创建池
	pool := tunny.NewFunc(4, func(data interface{}) interface{} {
		item := data.(string)
		time.Sleep(500 * time.Millisecond) // 模拟处理时间
		return fmt.Sprintf("处理后的-%s", item)
	})
	defer pool.Close()

	// 待处理数据
	items := []string{"A", "B", "C", "D", "E", "F", "G", "H"}

	var wg sync.WaitGroup
	results := make([]string, len(items))

	for i, item := range items {
		wg.Add(1)
		go func(idx int, val string) {
			defer wg.Done()
			res, _ := pool.ProcessTimed(val, 1*time.Second)
			results[idx] = res.(string)
		}(i, item)
	}

	wg.Wait()
	fmt.Println("处理结果:", results)
}

性能考虑

1. 池大小选择：通常设置为CPU核心数的2-4倍
2. 任务队列长度：默认无限制，大量任务可能导致内存问题
3. 超时设置：根据任务特性设置合理超时
4. 资源释放：记得调用Close()释放资源

与其他库的比较

• 相比ants：tunny更轻量，API更简单
• 相比workerpool：tunny支持超时控制
• 相比原生Goroutine：tunny避免了频繁创建销毁的开销

tunny是一个简单高效的Goroutine池实现，适合需要控制并发数量的场景，特别是当任务执行时间较长或任务量较大时，能显著提升性能。