使用 Goroutine 和 Channel 来实现更复杂的并发模式，如并发任务执行、并发数据处理，如何做？

使用 Goroutine 和 Channel 来实现更复杂的并发模式是 Go 语言的强大特性之一。

下面分别介绍如何实现并发任务执行和并发数据处理：

并发任务执行：

假设您有一些任务需要并发地执行，您可以使用 Goroutine 来同时执行这些任务，然后使用 Channel 来汇总结果。

下面是一个示例，展示如何使用 Goroutine 和 Channel 并发执行任务并收集结果：

go 复制代码

package main

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

func worker(id int, jobs <-chan int, results chan<- int) {
	for job := range jobs {
		fmt.Printf("Worker %d started job %d\n", id, job)
		time.Sleep(time.Second) // 模拟任务执行
		results <- job * 2      // 将结果发送到通道
		fmt.Printf("Worker %d finished job %d\n", id, job)
	}
}

func main() {
	const numJobs = 10
	const numWorkers = 3

	jobs := make(chan int, numJobs)
	results := make(chan int, numJobs)

	// 创建并启动多个工作 Goroutine
	var wg sync.WaitGroup
	for i := 1; i <= numWorkers; i++ {
		wg.Add(1)
		go func(workerID int) {
			defer wg.Done()
			worker(workerID, jobs, results)
		}(i)
	}

	// 提供任务给工作 Goroutine
	for i := 1; i <= numJobs; i++ {
		jobs <- i
	}
	close(jobs)

	// 等待所有工作完成
	wg.Wait()
	close(results)

	// 收集任务结果
	for result := range results {
		fmt.Println("Result:", result)
	}
}

在此示例中，我们创建了一些工作任务并将它们放入 jobs 通道中，然后启动了多个工作 Goroutine 来从 jobs 通道中获取任务并执行。每个工作 Goroutine 将结果发送到 results 通道中，然后主程序从 results 通道中收集结果。

并发数据处理：

假设您有一些数据需要并发地处理，您可以将数据分割成块，并使用 Goroutine 来并发处理每个块数据。下面是一个示例，展示如何使用 Goroutine 和 Channel 并发处理数据：

go 复制代码

package main

import (
	"fmt"
	"sync"
)

func processData(data []int, results chan<- int) {
	result := 0
	for _, num := range data {
		result += num
	}
	results <- result
}

func main() {
	data := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	const numWorkers = 3

	chunkSize := len(data) / numWorkers

	results := make(chan int, numWorkers)

	var wg sync.WaitGroup
	for i := 0; i < numWorkers; i++ {
		wg.Add(1)
		start := i * chunkSize
		end := (i + 1) * chunkSize
		go func() {
			defer wg.Done()
			processData(data[start:end], results)
		}()
	}

	wg.Wait()
	close(results)

	totalResult := 0
	for result := range results {
		totalResult += result
	}

	fmt.Println("Total result:", totalResult)
}

在此示例中，我们将数据分割成多个块，每个块数据由一个工作 Goroutine 并发处理，然后将处理结果发送到 results 通道中。主程序等待所有工作完成，然后从 results 通道中收集处理结果并计算总和。

这只是一些示例，您可以根据具体的应用场景和需求，灵活地使用 Goroutine 和 Channel 来实现各种并发模式。