go-flow: 控制Goroutines执行顺序的Golang插件库

go-flow是一个用于控制Goroutines执行顺序的Golang库，它提供了简单而强大的方式来管理并发任务的执行顺序和依赖关系。

基本概念

go-flow允许你：

• 定义任务的执行顺序
• 设置任务间的依赖关系
• 控制并发度
• 收集任务执行结果

安装

go get github.com/kamildrazkiewicz/go-flow

基本使用示例

package main

import (
	"fmt"
	"time"
	
	"github.com/kamildrazkiewicz/go-flow"
)

func main() {
	// 创建flow实例
	f := flow.New()
	
	// 添加任务
	f.Add("task1", func() (interface{}, error) {
		time.Sleep(1 * time.Second)
		fmt.Println("Task 1 executed")
		return "result1", nil
	})
	
	f.Add("task2", func() (interface{}, error) {
		time.Sleep(500 * time.Millisecond)
		fmt.Println("Task 2 executed")
		return "result2", nil
	})
	
	// 设置执行顺序：task1 -> task2
	f.After("task1", "task2")
	
	// 执行flow
	f.Run()
	
	// 获取结果
	result1, _ := f.GetResult("task1")
	result2, _ := f.GetResult("task2")
	
	fmt.Println("Result of task1:", result1)
	fmt.Println("Result of task2:", result2)
}

高级功能

1. 并行执行

f := flow.New()

// 添加并行任务
f.Add("taskA", func() (interface{}, error) {
    time.Sleep(1 * time.Second)
    return "A", nil
})

f.Add("taskB", func() (interface{}, error) {
    time.Sleep(2 * time.Second)
    return "B", nil
})

// 不设置依赖关系，它们会并行执行
f.Run()

2. 复杂依赖关系

f := flow.New()

f.Add("fetchData", fetchData)
f.Add("processData", processData)
f.Add("saveData", saveData)
f.Add("notifyUser", notifyUser)

// 设置依赖关系
f.After("fetchData", "processData")
f.After("processData", "saveData")
f.After("saveData", "notifyUser")

f.Run()

3. 错误处理

f := flow.New()

f.Add("task1", func() (interface{}, error) {
    return nil, fmt.Errorf("something went wrong")
})

f.Add("task2", func() (interface{}, error) {
    return "success", nil
})

f.After("task1", "task2")

err := f.Run()
if err != nil {
    fmt.Println("Flow execution failed:", err)
    
    // 获取特定任务的错误
    if taskErr := f.GetError("task1"); taskErr != nil {
        fmt.Println("Task1 error:", taskErr)
    }
}

4. 限制并发度

f := flow.New().SetMaxGoroutines(2) // 最多同时运行2个goroutine

// 添加多个任务...
f.Add("task1", task1)
f.Add("task2", task2)
f.Add("task3", task3)

f.Run() // 最多同时执行2个任务

实际应用场景

1. 数据处理管道

func main() {
    f := flow.New()
    
    // 定义处理步骤
    f.Add("readCSV", readCSVFile)
    f.Add("validateData", validateData)
    f.Add("transformData", transformData)
    f.Add("loadToDB", loadToDatabase)
    f.Add("generateReport", generateReport)
    
    // 设置处理流程
    f.After("readCSV", "validateData")
    f.After("validateData", "transformData")
    f.After("transformData", "loadToDB")
    f.After("loadToDB", "generateReport")
    
    if err := f.Run(); err != nil {
        log.Fatal("数据处理流程失败:", err)
    }
    
    report, _ := f.GetResult("generateReport")
    fmt.Println("报告生成成功:", report)
}

2. 微服务调用编排

func main() {
    f := flow.New()
    
    // 并行获取用户数据和订单数据
    f.Add("getUser", getUserService)
    f.Add("getOrders", getOrdersService)
    
    // 然后计算统计数据
    f.Add("calculateStats", calculateStatistics)
    
    // 设置依赖关系
    f.After("getUser", "calculateStats")
    f.After("getOrders", "calculateStats")
    
    if err := f.Run(); err != nil {
        log.Fatal("服务调用失败:", err)
    }
    
    stats, _ := f.GetResult("calculateStats")
    fmt.Println("统计结果:", stats)
}

性能考虑

1. 对于大量小任务，考虑批量处理
2. 合理设置最大并发数以避免资源耗尽
3. 长时间运行的任务可能需要超时控制

替代方案

如果go-flow不能满足需求，也可以考虑：

• errgroup (标准库扩展)
• golang.org/x/sync/semaphore
• 第三方库如conc (更适合结构化并发)

go-flow在需要明确任务依赖关系和执行顺序的场景下特别有用，它提供了比原生goroutine更结构化的并发控制方式。