Go进阶概览 -【5.5 并发编程中的常见模式与最佳实践】

5.5 并发编程中的常见模式与最佳实践

在现代编程中，并发编程是提高程序性能和响应速度的关键技术之一。

Go语言以其轻量级的协程和强大的并发支持，成为了处理并发任务的理想选择。

本节将介绍Go语言中常见的并发编程模式，并探讨如何编写高效可靠的并发代码。

本节代码存放目录为 lesson17

生产者-消费者模式

生产者-消费者模式是一种经典的并发模式，通常用于解决生产者与消费者速度不一致的问题。

生产者负责生成数据，而消费者负责处理数据。通过引入缓冲区（通常使用 channel），生产者和消费者可以并发工作，而无需相互等待。

实现代码如下所示：

func producer(ch chan<- int, wg *sync.WaitGroup) {
	defer wg.Done()
	for i := 0; i < 10; i++ {
		ch <- i
		fmt.Println("Produced: ", i)
		time.Sleep(time.Duration(1) * time.Second)
	}
	close(ch)
}

func consumer(ch <-chan int, wg *sync.WaitGroup) {
	defer wg.Done()
	for item := range ch {
		fmt.Println("Consumed: ", item)
	}
}

func main() {
	var (
		wg sync.WaitGroup
	)
	ch := make(chan int, 5)
	
	wg.Add(2)
	go producer(ch, &wg)
	go consumer(ch, &wg)
	wg.Wait()
}

使用注意点

• 使用close关闭channel，防止消费者在无数据可读时死锁。

• 使用缓冲通道提高生产者和消费者之间的处理效率。

---

工作池模式

工作池模式用于在处理大量任务时，限制同时执行的任务数量。

通过固定数量的Goroutine（工人），我们可以高效地处理大量任务，同时控制资源的使用。

实现代码如下所示：

func worker(id int, jobs <-chan int, results chan<- int, wg *sync.WaitGroup) {
	defer wg.Done()
	for j := range jobs {
		fmt.Printf("Worker %d started job %d\n", id, j)
		time.Sleep(time.Second)
		fmt.Printf("Worker %d finished job %d\n", id, j)
		results <- j * 2
	}
}

func main() {
	var (
		wg sync.WaitGroup
	)
	jobs := make(chan int, 100)
	results := make(chan int, 100)

	for w := 1; w <= 3; w++ {
		wg.Add(1)
		go worker(w, jobs, results, &wg)
	}

	for j := 1; j <= 9; j++ {
		jobs <- j
	}
	close(jobs)

	wg.Wait()
	close(results)

	for r := range results {
		fmt.Println("Result: ", r)
	}
}

使用注意点

• 设置适当的Worker数量以平衡资源使用和任务处理速度。

• 使用sync.WaitGroup确保所有任务完成后程序再退出。

---

扇入扇出模式

扇入扇出模式常用于将多个输入源的结果汇总到一起，或将单个任务分解为多个并发子任务来处理，然后将结果汇总。

实现代码如下所示：

func process(id int, ch chan<- int) {
	defer close(ch)
	result := id * 2
	fmt.Printf("Process %d done\n", id)
	ch <- result
}

func fanIn(channels ...<-chan int) <-chan int {
	out := make(chan int)
	var (
		wg sync.WaitGroup
	)
	wg.Add(len(channels))

	for _, ch := range channels {
		go func(c <-chan int) {
			defer wg.Done()
			for val := range c {
				out <- val
			}
		}(ch)
	}

	go func() {
		wg.Wait()
		close(out) // 确保所有 Goroutine 处理完毕后关闭输出通道
	}()

	return out
}

func main() {
	channels := make([]chan int, 3)
	for i := range channels {
		channels[i] = make(chan int)
		go process(i+1, channels[i])
	}

	resultCh := fanIn(channels[0], channels[1], channels[2])
	for result := range resultCh {
		fmt.Println("Received:", result)
	}
}

使用注意点

• 确保所有输入channel都被关闭，防止数据泄漏或死锁。

• 使用扇入机制简化结果的汇总和处理。

---

超时与取消

在并发编程中，处理任务超时和取消非常重要，尤其是当某些任务可能无法在合理的时间内完成时。

实现代码如下所示：

func worker(ctx context.Context, id int, ch chan<- int) {
	select {
	case <-time.After(4 * time.Second):
		ch <- id * 2
	case <-ctx.Done():
		fmt.Printf("Worker %d canceled\n", id)
	}
}

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()

	ch := make(chan int)
	for i := 1; i <= 5; i++ {
		go worker(ctx, i, ch)
	}

	for i := 1; i <= 5; i++ {
		select {
		case res := <-ch:
			fmt.Println("Received: ", res)
		case <-ctx.Done():
			fmt.Println("Main canceled")
			return
		}
	}
}

使用注意点

• 使用context包来处理超时和取消任务。

• 确保Goroutine在取消时能够正确释放资源，防止资源泄漏。

总结

Go语言提供了丰富的并发编程支持，合理使用这些并发模式可以大大提升程序的性能和可维护性。

在实际开发中，应根据具体场景选择合适的并发模式，并结合Go语言的特性和最佳实践，编写高效可靠的并发代码。