Go-Floc: 轻松编排Goroutines的并发控制库

Go-Floc 是一个用于编排和控制goroutines并发流程的Go语言库，它提供了一种声明式的方式来管理并发任务。下面我将详细介绍它的使用方法和示例代码。

基本概念

Go-Floc 的核心概念包括：

• Flow - 表示一组任务的执行流程
• Control - 控制流程的执行和取消
• State - 在任务间共享的状态

安装

go get github.com/workanator/go-floc

基本使用示例

1. 简单顺序执行

package main

import (
	"fmt"
	"github.com/workanator/go-floc"
	"github.com/workanator/go-floc/run"
)

func main() {
	// 创建流程
	flow := run.Sequence(
		func(ctx floc.Context, ctrl floc.Control, data interface{}) {
			fmt.Println("Task 1")
		},
		func(ctx floc.Context, ctrl floc.Control, data interface{}) {
			fmt.Println("Task 2")
		},
	)

	// 运行流程
	floc.Run(flow)
}

2. 并行执行任务

package main

import (
	"fmt"
	"github.com/workanator/go-floc"
	"github.com/workanator/go-floc/run"
)

func main() {
	flow := run.Parallel(
		func(ctx floc.Context, ctrl floc.Control, data interface{}) {
			fmt.Println("Parallel Task 1")
		},
		func(ctx floc.Context, ctrl floc.Control, data interface{}) {
			fmt.Println("Parallel Task 2")
		},
	)

	floc.Run(flow)
}

3. 带状态的任务

package main

import (
	"fmt"
	"github.com/workanator/go-floc"
	"github.com/workanator/go-floc/run"
)

func main() {
	flow := run.Sequence(
		func(ctx floc.Context, ctrl floc.Control, data interface{}) {
			// 修改共享状态
			state := data.(map[string]interface{})
			state["count"] = 1
		},
		func(ctx floc.Context, ctrl floc.Control, data interface{}) {
			// 读取共享状态
			state := data.(map[string]interface{})
			fmt.Printf("Current count: %d\n", state["count"])
		},
	)

	// 初始化共享状态
	state := make(map[string]interface{})
	floc.RunWith(flow, state)
}

4. 条件执行

package main

import (
	"fmt"
	"github.com/workanator/go-floc"
	"github.com/workanator/go-floc/pred"
	"github.com/workanator/go-floc/run"
)

func main() {
	flow := run.If(
		pred.True(), // 条件判断
		func(ctx floc.Context, ctrl floc.Control, data interface{}) {
			fmt.Println("Condition is true")
		},
		func(ctx floc.Context, ctrl floc.Control, data interface{}) {
			fmt.Println("Condition is false")
		},
	)

	floc.Run(flow)
}

5. 循环执行

package main

import (
	"fmt"
	"github.com/workanator/go-floc"
	"github.com/workanator/go-floc/pred"
	"github.com/workanator/go-floc/run"
)

func main() {
	flow := run.Loop(
		func(ctx floc.Context, ctrl floc.Control, data interface{}) {
			state := data.(map[string]interface{})
			count := state["count"].(int)
			fmt.Printf("Iteration %d\n", count)
			state["count"] = count + 1
		},
		pred.LessThan(5), // 循环条件
	)

	// 初始化状态
	state := map[string]interface{}{"count": 0}
	floc.RunWith(flow, state)
}

6. 超时控制

package main

import (
	"fmt"
	"time"
	"github.com/workanator/go-floc"
	"github.com/workanator/go-floc/run"
)

func main() {
	flow := run.Sequence(
		func(ctx floc.Context, ctrl floc.Control, data interface{}) {
			// 设置超时
			deadline := time.Now().Add(2 * time.Second)
			ctx.Update(deadline)
		},
		func(ctx floc.Context, ctrl floc.Control, data interface{}) {
			// 模拟长时间运行任务
			select {
			case <-time.After(3 * time.Second):
				fmt.Println("Task completed")
			case <-ctx.Done():
				fmt.Println("Task canceled due to timeout")
				ctrl.Cancel(nil)
			}
		},
	)

	floc.Run(flow)
}

高级特性

1. 组合流程

package main

import (
	"fmt"
	"github.com/workanator/go-floc"
	"github.com/workanator/go-floc/run"
)

func main() {
	subFlow1 := run.Sequence(
		func(ctx floc.Context, ctrl floc.Control, data interface{}) {
			fmt.Println("Sub-task 1")
		},
		func(ctx floc.Context, ctrl floc.Control, data interface{}) {
			fmt.Println("Sub-task 2")
		},
	)

	subFlow2 := run.Parallel(
		func(ctx floc.Context, ctrl floc.Control, data interface{}) {
			fmt.Println("Parallel sub-task 1")
		},
		func(ctx floc.Context, ctrl floc.Control, data interface{}) {
			fmt.Println("Parallel sub-task 2")
		},
	)

	mainFlow := run.Sequence(subFlow1, subFlow2)

	floc.Run(mainFlow)
}

2. 错误处理

package main

import (
	"fmt"
	"errors"
	"github.com/workanator/go-floc"
	"github.com/workanator/go-floc/run"
)

func main() {
	flow := run.Sequence(
		func(ctx floc.Context, ctrl floc.Control, data interface{}) {
			fmt.Println("Task 1")
		},
		func(ctx floc.Context, ctrl floc.Control, data interface{}) {
			// 模拟错误
			ctrl.Fail(errors.New("something went wrong"))
		},
		func(ctx floc.Context, ctrl floc.Control, data interface{}) {
			// 这个任务不会执行
			fmt.Println("Task 3")
		},
	)

	result, _, _ := floc.Run(flow)
	if result.IsFailed() {
		fmt.Printf("Flow failed: %v\n", result.Error())
	}
}

总结

Go-Floc 提供了强大的goroutine编排能力，主要特点包括：

1. 声明式API设计，代码可读性高
2. 支持顺序、并行、条件、循环等流程控制
3. 内置状态管理和错误处理机制
4. 支持超时控制和流程取消

通过组合这些基本构建块，你可以创建复杂的并发流程，而无需手动管理goroutine的生命周期和同步问题。

对于更复杂的场景，你还可以探索Go-Floc提供的其他功能，如后台任务、延迟执行、事件触发等高级特性。