Go 实现父子任务进度同步

package main

import "fmt"

// StageProgress 接口定义了任务的基本操作
type StageProgress interface {
	Step()         // 按默认步长推进
	StepBy(n int)  // 按自定义步长推进
	Finish()       // 完成任务
	Percent() int  // 获取当前进度的百分比
}

// StageStepper 结构体实现了 StageProgress 接口
type StageStepper struct {
	total       int               // 总步数
	current     int               // 当前步数
	defaultStep int               // 默认步长
	onUpdate    func(delta, percent int) // 进度更新回调函数
}

// 创建 StageStepper 实例
func NewStageStepper(total int, defaultStep int, onUpdate func(delta, percent int)) StageProgress {
	if total <= 0 {
		total = 1
	}
	if defaultStep <= 0 {
		defaultStep = 1
	}
	if onUpdate == nil {
		onUpdate = func(delta, percent int) {}
	}

	return &StageStepper{
		total:       total,
		current:     0,
		defaultStep: defaultStep,
		onUpdate:    onUpdate,
	}
}

// 步进
func (s *StageStepper) Step() {
	s.StepBy(s.defaultStep)
}

// 按自定义步长推进
func (s *StageStepper) StepBy(n int) {
	if n <= 0 || s.current >= s.total {
		return
	}

	remain := s.total - s.current
	if n > remain {
		n = remain
	}

	s.current += n
	s.emit(n)
}

// 完成任务
func (s *StageStepper) Finish() {
	remain := s.total - s.current
	if remain > 0 {
		s.current = s.total
		s.emit(remain)
	}
}

// 发出进度更新
func (s *StageStepper) emit(delta int) {
	if delta <= 0 {
		return
	}
	s.onUpdate(delta, s.Percent())
}

// 计算进度百分比
func (s *StageStepper) Percent() int {
	if s.total <= 0 {
		return 100
	}
	if s.current <= 0 {
		return 0
	}
	if s.current >= s.total {
		return 100
	}
	return (s.current*100 + s.total/2) / s.total
}

func main() {
	// 使用 WaitGroup 来同步父任务和子任务
	var wg sync.WaitGroup

	// 父任务进度更新的回调
	parentTask := NewStageStepper(150, 10, func(delta, percent int) {
		fmt.Printf("Parent Task Progress: %d%% (Step: %d)\n", percent, delta)
	})

	// 子任务进度更新的回调
	subTask := NewStageStepper(50, 5, func(delta, percent int) {
		fmt.Printf("SubTask Progress: %d%% (Step: %d)\n", percent, delta)
		// 每次子任务步进时，通知父任务更新进度
		parentTask.StepBy(delta)
	})

	// 执行父任务
	wg.Add(1)
	go func() {
		defer wg.Done()
		for i := 0; i < 10; i++ {
			parentTask.Step()
		}
	}()

	// 执行子任务
	wg.Add(1)
	go func() {
		defer wg.Done()
		for i := 0; i < 5; i++ {
			subTask.Step()
		}
	}()

	// 等待所有 goroutine 完成
	wg.Wait()

	// 完成任务
	parentTask.Finish()
	subTask.Finish()
}