Go语言中WaitGroup并发同步利器

package main

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

func main() {
	var wg sync.WaitGroup
	
	// 启动多个协程
	for i := 0; i < 5; i++ {
		wg.Add(1) // 增加计数器
		go func(id int) {
			defer wg.Done() // 减少计数器
			fmt.Printf("Goroutine %d started\n", id)
			time.Sleep(1 * time.Second)
			fmt.Printf("Goroutine %d finished\n", id)
		}(i)
	}
	
	fmt.Println("Waiting for all goroutines to finish...")
	wg.Wait() // 等待所有协程完成
	fmt.Println("All goroutines finished")
}

package main

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

func main() {
	var wg sync.WaitGroup
	errCh := make(chan error, 5)
	
	// 启动多个协程
	for i := 0; i < 5; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			fmt.Printf("Goroutine %d started\n", id)
			time.Sleep(1 * time.Second)
			
			// 模拟错误
			if id == 2 {
				errCh <- fmt.Errorf("error in goroutine %d", id)
				return
			}
			
			fmt.Printf("Goroutine %d finished\n", id)
		}(i)
	}
	
	// 等待所有协程完成
	go func() {
		wg.Wait()
		close(errCh)
	}()
	
	// 收集错误
	for err := range errCh {
		fmt.Println("Error:", err)
	}
	
	fmt.Println("All goroutines finished")
}

package main

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

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()
	
	var wg sync.WaitGroup
	
	// 启动多个协程
	for i := 0; i < 5; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			fmt.Printf("Goroutine %d started\n", id)
			
			// 检查上下文是否取消
			select {
			case <-ctx.Done():
				fmt.Printf("Goroutine %d cancelled\n", id)
				return
			case <-time.After(2 * time.Second):
				fmt.Printf("Goroutine %d finished\n", id)
			}
		}(i)
	}
	
	// 等待所有协程完成或上下文取消
	wg.Wait()
	fmt.Println("All goroutines finished")
}

package main

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

func main() {
	var wg sync.WaitGroup
	resultCh := make(chan int, 5)
	
	// 启动多个协程
	for i := 0; i < 5; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			fmt.Printf("Goroutine %d started\n", id)
			time.Sleep(1 * time.Second)
			resultCh <- id * 2
			fmt.Printf("Goroutine %d finished\n", id)
		}(i)
	}
	
	// 等待所有协程完成
	go func() {
		wg.Wait()
		close(resultCh)
	}()
	
	// 收集结果
	for result := range resultCh {
		fmt.Println("Result:", result)
	}
	
	fmt.Println("All goroutines finished")
}

package main

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

func processTask(id int) {
	fmt.Printf("Processing task %d\n", id)
	time.Sleep(1 * time.Second)
	fmt.Printf("Task %d processed\n", id)
}

func main() {
	var wg sync.WaitGroup
	tasks := []int{1, 2, 3, 4, 5}
	
	// 并行处理任务
	for _, task := range tasks {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			processTask(id)
		}(task)
	}
	
	// 等待所有任务完成
	fmt.Println("Waiting for all tasks to complete...")
	wg.Wait()
	fmt.Println("All tasks completed")
}

package main

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

func downloadFile(url string) {
	fmt.Printf("Downloading %s\n", url)
	time.Sleep(2 * time.Second) // 模拟下载时间
	fmt.Printf("Downloaded %s\n", url)
}

func main() {
	var wg sync.WaitGroup
	urls := []string{
		"https://example.com/file1.txt",
		"https://example.com/file2.txt",
		"https://example.com/file3.txt",
		"https://example.com/file4.txt",
		"https://example.com/file5.txt",
	}
	
	// 并发下载文件
	for _, url := range urls {
		wg.Add(1)
		go func(u string) {
			defer wg.Done()
			downloadFile(u)
		}(url)
	}
	
	// 等待所有下载完成
	fmt.Println("Waiting for all downloads to complete...")
	wg.Wait()
	fmt.Println("All downloads completed")
}

package main

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

func queryDatabase(id int) {
	fmt.Printf("Querying database for id %d\n", id)
	time.Sleep(500 * time.Millisecond) // 模拟数据库查询时间
	fmt.Printf("Query completed for id %d\n", id)
}

func main() {
	var wg sync.WaitGroup
	ids := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	
	// 并发查询数据库
	for _, id := range ids {
		wg.Add(1)
		go func(i int) {
			defer wg.Done()
			queryDatabase(i)
		}(id)
	}
	
	// 等待所有查询完成
	fmt.Println("Waiting for all database queries to complete...")
	wg.Wait()
	fmt.Println("All database queries completed")
}