Golang进程池管理插件execpool使用指南

execpool是一个轻量级的Golang进程池管理库，它可以帮助你管理和复用进程，特别适合需要频繁创建子进程的场景。下面我将详细介绍execpool的使用方法。

安装

首先安装execpool包：

go get github.com/ivpusic/execpool

基本使用

1. 创建进程池

package main

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

func main() {
	// 创建一个最大容量为5的进程池
	pool, err := execpool.NewPool(5)
	if err != nil {
		panic(err)
	}
	defer pool.Close() // 使用完毕后关闭进程池

	// 使用进程池执行命令
	cmd := pool.Command("echo", "Hello, execpool!")
	output, err := cmd.Output()
	if err != nil {
		fmt.Printf("Command execution error: %v\n", err)
		return
	}

	fmt.Printf("Output: %s\n", output)
}

2. 并发执行多个命令

func concurrentExample() {
	pool, err := execpool.NewPool(3) // 限制并发数为3
	if err != nil {
		panic(err)
	}
	defer pool.Close()

	// 准备要执行的命令列表
	commands := []struct {
		name string
		args []string
	}{
		{"date", []string{"+%Y-%m-%d"}},
		{"whoami", nil},
		{"ls", []string{"-l"}},
		{"pwd", nil},
	}

	// 使用WaitGroup等待所有命令完成
	var wg sync.WaitGroup
	results := make(chan string, len(commands))

	for _, cmd := range commands {
		wg.Add(1)
		go func(name string, args []string) {
			defer wg.Done()
			
			cmd := pool.Command(name, args...)
			output, err := cmd.CombinedOutput()
			if err != nil {
				results <- fmt.Sprintf("Error executing %s: %v", name, err)
				return
			}
			results <- fmt.Sprintf("%s output:\n%s", name, output)
		}(cmd.name, cmd.args)
	}

	// 启动一个goroutine等待所有命令完成
	go func() {
		wg.Wait()
		close(results)
	}()

	// 打印结果
	for result := range results {
		fmt.Println(result)
	}
}

高级功能

1. 设置超时

func timeoutExample() {
	pool, err := execpool.NewPool(2)
	if err != nil {
		panic(err)
	}
	defer pool.Close()

	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()

	cmd := pool.CommandContext(ctx, "sleep", "5")
	output, err := cmd.CombinedOutput()
	if err != nil {
		if ctx.Err() == context.DeadlineExceeded {
			fmt.Println("Command timed out")
		} else {
			fmt.Printf("Command failed: %v\n", err)
		}
		return
	}

	fmt.Printf("Output: %s\n", output)
}

2. 自定义环境变量

func envExample() {
	pool, err := execpool.NewPool(1)
	if err != nil {
		panic(err)
	}
	defer pool.Close()

	cmd := pool.Command("printenv", "MY_VAR")
	cmd.Env = append(os.Environ(), "MY_VAR=custom_value")
	
	output, err := cmd.Output()
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}
	
	fmt.Printf("MY_VAR value: %s\n", output)
}

3. 获取进程统计信息

func statsExample() {
	pool, err := execpool.NewPool(3)
	if err != nil {
		panic(err)
	}
	defer pool.Close()

	// 执行一些命令
	for i := 0; i < 5; i++ {
		cmd := pool.Command("echo", fmt.Sprintf("Task %d", i))
		cmd.Run()
	}

	// 获取统计信息
	stats := pool.Stats()
	fmt.Printf("Pool stats:\n")
	fmt.Printf("  Max processes: %d\n", stats.Max)
	fmt.Printf("  Current active processes: %d\n", stats.Active)
	fmt.Printf("  Total allocated processes: %d\n", stats.Allocated)
	fmt.Printf("  Total commands executed: %d\n", stats.Executed)
}

最佳实践

1. 合理设置池大小：根据系统资源和任务特性设置合适的池大小，避免资源耗尽。

2. 总是关闭进程池：使用defer pool.Close()确保资源被正确释放。

3. 处理超时：长时间运行的命令应该设置超时，避免阻塞整个应用。

4. 错误处理：仔细检查命令执行结果，处理可能的错误。

5. 复用进程池：对于需要频繁创建子进程的应用，应该复用同一个进程池实例。

execpool通过复用进程资源，可以显著提高需要频繁创建子进程的应用性能，特别是在高并发场景下。相比每次创建新进程，使用进程池可以减少系统开销，提高响应速度。