package main

import (
	"fmt"
	"sync"
	"time"
)

func main() {
	waitGroupReuseExample()
	println("\n==================")
	benchmark()
}

func waitGroupReuseExample() {
	fmt.Println("=== WaitGroup 复用示例 ===")
	fmt.Println("开始时间:", time.Now().Format("15:04:05.000"))
	var wg sync.WaitGroup

	// 第一批任务
	fmt.Println("\n=== 第一批任务, 每个任务执行1秒 ===")
	wg.Add(2)

	for i := 1; i <= 2; i++ {
		go func(id int) {
			taskStart := time.Now()
			defer wg.Done()
			fmt.Printf("[%s] 第一批任务 %d: 执行中...\n", taskStart.Format("15:04:05.000"), id)
			time.Sleep(1 * time.Second)
		}(i)
	}

	wg.Wait() // 关键：必须等待第一批完成
	fmt.Printf("[%s] 第一批任务全部完成\n", time.Now().Format("15:04:05.000"))

	// 第二批任务
	fmt.Println("\n=== 第二批任务, 每个任务执行2秒 ===")
	wg.Add(3) // 可以安全地重新开始新批次

	for i := 1; i <= 3; i++ {
		go func(id int) {
			defer wg.Done()
			fmt.Printf("[%s] 第二批任务 %d: 执行中...\n", time.Now().Format("15:04:05.000"), id)
			time.Sleep(2 * time.Second)
		}(i)
	}

	wg.Wait()
	fmt.Printf("[%s] 第二批任务全部完成\n", time.Now().Format("15:04:05.000"))
}

func benchmark() {
	const numBatches = 10000
	const tasksPerBatch = 10

	fmt.Println("=== 性能对比：复用 vs 不复用 ===")

	// 测试1：不复用（每次创建新的）
	start1 := time.Now()
	for i := 0; i < numBatches; i++ {
		var wg sync.WaitGroup
		wg.Add(tasksPerBatch)
		for j := 0; j < tasksPerBatch; j++ {
			go func() {
				defer wg.Done()
				// 空任务，只测试WaitGroup开销
			}()
		}
		wg.Wait()
	}
	time1 := time.Since(start1)

	// 测试2：复用（同一个WaitGroup）
	start2 := time.Now()
	var wg sync.WaitGroup
	for i := 0; i < numBatches; i++ {
		wg.Add(tasksPerBatch)
		for j := 0; j < tasksPerBatch; j++ {
			go func() {
				defer wg.Done()
				// 空任务
			}()
		}
		wg.Wait() // 等待归零，准备下一批
	}
	time2 := time.Since(start2)

	fmt.Printf("不复用（每次新建）耗时: %v\n", time1)
	fmt.Printf("复用（同一WaitGroup）耗时: %v\n", time2)
	fmt.Printf("复用性能提升: %.1f%%\n",
		float64(time1-time2)/float64(time1)*100)
}