go-taskflow@v0.1.0的发布确实为Go语言的并行编程带来了一个强大的新工具。从特性来看，这个框架在任务编排的灵活性和可视化调试方面做得相当出色。让我通过一个完整的示例来展示它的核心功能：

package main

import (
	"fmt"
	"log"
	"os"
	"runtime"
	"time"

	gotaskflow "github.com/noneback/go-taskflow"
)

func main() {
	// 1. 创建执行器，使用CPU核心数-1的并发度
	executor := gotaskflow.NewExecutor(uint(runtime.NumCPU() - 1))
	
	// 2. 创建任务流
	tf := gotaskflow.NewTaskFlow("示例工作流")
	
	// 3. 定义任务节点
	A := gotaskflow.NewTask("A", func() {
		time.Sleep(100 * time.Millisecond)
		fmt.Println("执行任务A")
	})
	
	B := gotaskflow.NewTask("B", func() {
		time.Sleep(150 * time.Millisecond)
		fmt.Println("执行任务B")
	})
	
	C := gotaskflow.NewTask("C", func() {
		time.Sleep(200 * time.Millisecond)
		fmt.Println("执行任务C")
	})
	
	D := gotaskflow.NewTask("D", func() {
		time.Sleep(50 * time.Millisecond)
		fmt.Println("执行任务D")
	})
	
	// 4. 构建任务依赖关系：A -> B -> D, A -> C -> D
	tf.AddTask(A, B, C, D)
	tf.AddDependency(A, B)
	tf.AddDependency(A, C)
	tf.AddDependency(B, D)
	tf.AddDependency(C, D)
	
	// 5. 执行任务流
	start := time.Now()
	if err := executor.Run(tf); err != nil {
		log.Fatal(err)
	}
	
	fmt.Printf("总执行时间: %v\n", time.Since(start))
	
	// 6. 生成可视化图表
	dotFile, err := os.Create("taskflow.dot")
	if err != nil {
		log.Fatal(err)
	}
	defer dotFile.Close()
	
	if err := tf.Visualize(dotFile); err != nil {
		log.Fatal(err)
	}
	
	// 7. 性能分析
	profile := executor.GetProfile(tf)
	fmt.Printf("关键路径长度: %v\n", profile.CriticalPathLength)
	fmt.Printf("总任务数: %d\n", profile.TotalTasks)
}

新版本支持的循环任务功能特别值得关注，这在处理批量数据或需要重复执行的任务时非常有用：

// 循环任务示例
func loopTaskExample() {
	executor := gotaskflow.NewExecutor(4)
	tf := gotaskflow.NewTaskFlow("循环任务示例")
	
	// 创建循环任务
	loopTask := gotaskflow.NewLoopTask("数据处理循环", func(iteration int) {
		fmt.Printf("第%d次迭代处理\n", iteration+1)
		// 模拟数据处理
		time.Sleep(50 * time.Millisecond)
	}, 5) // 循环5次
	
	// 前置任务
	initTask := gotaskflow.NewTask("初始化", func() {
		fmt.Println("初始化数据源")
	})
	
	// 后置任务
	finalTask := gotaskflow.NewTask("清理", func() {
		fmt.Println("清理资源")
	})
	
	// 构建依赖：初始化 -> 循环 -> 清理
	tf.AddTask(initTask, loopTask, finalTask)
	tf.AddDependency(initTask, loopTask)
	tf.AddDependency(loopTask, finalTask)
	
	// 执行
	if err := executor.Run(tf); err != nil {
		log.Fatal(err)
	}
}

条件任务的示例展示了如何根据运行时状态决定执行路径：

func conditionalTaskExample() {
	executor := gotaskflow.NewExecutor(2)
	tf := gotaskflow.NewTaskFlow("条件任务示例")
	
	dataReady := false
	
	checkTask := gotaskflow.NewTask("检查数据", func() {
		fmt.Println("检查数据准备状态")
		// 模拟检查逻辑
		dataReady = true
	})
	
	processTask := gotaskflow.NewTask("处理数据", func() {
		fmt.Println("处理数据")
	})
	
	skipTask := gotaskflow.NewTask("跳过处理", func() {
		fmt.Println("数据未就绪，跳过处理")
	})
	
	// 条件任务：根据dataReady决定执行路径
	conditionTask := gotaskflow.NewConditionTask("条件分支", func() int {
		if dataReady {
			return 0 // 执行processTask
		}
		return 1 // 执行skipTask
	})
	
	tf.AddTask(checkTask, conditionTask, processTask, skipTask)
	tf.AddDependency(checkTask, conditionTask)
	tf.AddConditionalDependency(conditionTask, 0, processTask)
	tf.AddConditionalDependency(conditionTask, 1, skipTask)
	
	if err := executor.Run(tf); err != nil {
		log.Fatal(err)
	}
}

框架的性能监控功能通过内置的分析器提供了详细的执行洞察：

func performanceMonitoringExample() {
	executor := gotaskflow.NewExecutor(8)
	
	// 创建复杂任务流
	tf := gotaskflow.NewTaskFlow("性能测试")
	
	// 添加多个并行任务
	tasks := make([]*gotaskflow.Task, 10)
	for i := 0; i < 10; i++ {
		taskName := fmt.Sprintf("任务%d", i)
		tasks[i] = gotaskflow.NewTask(taskName, func() {
			// 模拟不同长度的任务
			time.Sleep(time.Duration(i*20) * time.Millisecond)
		})
		tf.AddTask(tasks[i])
	}
	
	// 添加一些依赖关系
	for i := 0; i < 5; i++ {
		for j := i + 1; j < i + 3 && j < 10; j++ {
			tf.AddDependency(tasks[i], tasks[j])
		}
	}
	
	// 执行并分析
	if err := executor.Run(tf); err != nil {
		log.Fatal(err)
	}
	
	// 获取详细性能报告
	report := executor.Analyze(tf)
	fmt.Printf("并行度利用率: %.2f%%\n", report.ParallelismUtilization*100)
	fmt.Printf("最长任务执行时间: %v\n", report.MaxTaskDuration)
	fmt.Printf("最短任务执行时间: %v\n", report.MinTaskDuration)
	
	// 导出性能数据
	if err := report.ExportJSON("performance_report.json"); err != nil {
		log.Printf("导出性能报告失败: %v", err)
	}
}

这个框架的设计很好地结合了Go的并发特性和现代任务编排的需求。可视化工具对于调试复杂依赖关系特别有价值，而性能监控功能则帮助识别瓶颈任务。循环任务的加入确实让框架从单纯的DAG编排升级为完整的通用并行编程框架。