Golang 并发编程详解

Golang 并发编程详解

介绍

并发是现代软件开发中的一个重要概念，它允许程序同时执行多个任务，提高系统的性能和响应能力。Golang 是一门天生支持并发的语言，它通过 goroutine 和 channel 提供了强大的并发编程支持。

在本文中，我们将深入探讨 Golang 中的并发编程，了解 goroutine、channel 以及一些常见的并发模式。

Goroutine

Goroutine 是 Golang 中的轻量级线程，由 Go 运行时系统调度。它们比传统的线程更轻便，创建和销毁的代价更小，使得在程序中创建成千上万个 goroutine 变得实际可行。

创建 Goroutine

在 Golang 中创建 goroutine 非常简单。只需在函数调用前使用关键字 go 就可以将其包装成 goroutine。

package main

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

func printNumbers() {
	for i := 1; i <= 5; i++ {
		time.Sleep(100 * time.Millisecond)
		fmt.Printf("%d ", i)
	}
}

func main() {
	go printNumbers()

	// 主 goroutine 不等待 printNumbers 完成
	time.Sleep(1 * time.Second)

	fmt.Println("Main goroutine")
}

上述代码中，printNumbers 函数被包装成一个 goroutine，并在 main 函数中异步执行。time.Sleep(1 * time.Second) 用于等待足够的时间，确保 printNumbers 有足够的时间打印数字。注意，主 goroutine 并不会等待 printNumbers 执行完毕。

Channel

Channel 是 Golang 中用于在 goroutine 之间传递数据的管道。它提供了一种同步的方式，确保数据安全地在 goroutine 之间传递。

创建 Channel

在 Golang 中，使用 make 函数创建 channel。

ch := make(chan int)

上述代码创建了一个整数类型的无缓冲 channel。无缓冲 channel 在发送数据和接收数据时都会阻塞，直到另一方准备好。

使用 Channel

package main

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

func printNumbers(ch chan int, wg *sync.WaitGroup) {
	defer wg.Done()

	for i := 1; i <= 5; i++ {
		time.Sleep(100 * time.Millisecond)
		ch <- i
	}
	close(ch)
}

func main() {
	ch := make(chan int)
	var wg sync.WaitGroup

	wg.Add(1)
	go printNumbers(ch, &wg)

	for num := range ch {
		fmt.Printf("%d ", num)
	}

	fmt.Println("Main goroutine")
	wg.Wait()
}

上述代码中，printNumbers 将数字通过 channel 发送给主 goroutine，并在发送完毕后关闭 channel。主 goroutine 使用 for num := range ch 循环接收 channel 中的数据，直到 channel 被关闭。同时，使用等待组（sync.WaitGroup）确保所有 goroutine 执行完毕后主 goroutine 才结束。

并发模式

除了简单的 goroutine 和 channel 的使用外，Golang 还提供了一些常见的并发模式，如等待组、互斥锁等。这些模式帮助我们更好地组织和管理并发代码。

等待组

等待组（WaitGroup）用于等待一组 goroutine 执行完毕。它通过计数器实现，每个 goroutine 执行前递增计数器，执行完毕后递减计数器。主 goroutine 调用 Wait 方法等待计数器归零。

package main

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

func printNumbers(wg *sync.WaitGroup) {
	defer wg.Done()

	for i := 1; i <= 5; i++ {
		time.Sleep(100 * time.Millisecond)
		fmt.Printf("%d ", i)
	}
}

func main() {
	var wg sync.WaitGroup

	wg.Add(1)
	go printNumbers(&wg)

	wg.Wait()
	fmt.Println("Main goroutine")
}

互斥锁

互斥锁（Mutex）用于保护共享资源，防止多个 goroutine 同时访问导致的竞态条件。

package main

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

var counter = 0
var mutex sync.Mutex

func increment(wg *sync.WaitGroup) {
	defer wg.Done()

	for i := 0; i < 1000; i++ {
		mutex.Lock()
		counter++
		mutex.Unlock()
	}
}

func main() {
	var wg sync.WaitGroup

	wg.Add(2)
	go increment(&wg)
	go increment(&wg)

	wg.Wait()
	fmt.Printf("Final Counter: %d\n", counter)
}

上述代码中，两个 goroutine 并发地增加 counter 变量的值，使用互斥锁 sync.Mutex 来保护临界区，确保同一时刻只有一个 goroutine 能够访问。

使用 Select 处理多 Channel

在一些场景中，我们可能需要同时处理多个 channel，Golang 中提供了 select 语句来实现。

package main

import (
	"fmt"
	"time"
)

func producer(ch chan int, wg *sync.WaitGroup) {
	defer wg.Done()

	for i := 1; i <= 5; i++ {
		time.Sleep(100 * time.Millisecond)
		ch <- i
	}
	close(ch)
}

func consumer(ch1, ch2 chan int, wg *sync.WaitGroup) {
	defer wg.Done()

	for {
		select {
		case num, ok := <-ch1:
			if ok {
				fmt.Printf("From ch1: %d\n", num)
			}
		case num, ok := <-ch2:
			if ok {
				fmt.Printf("From ch2: %d\n", num)
			}
		}
	}
}

func main() {
	ch1 := make(chan int)
	ch2 := make(chan int)
	var wg sync.WaitGroup

	wg.Add(2)
	go producer(ch1, &wg)
	go producer(ch2, &wg)



	go consumer(ch1, ch2, &wg)

	wg.Wait()
	fmt.Println("Main goroutine")
}

上述代码中，consumer 函数通过 select 同时监听两个 channel（ch1 和 ch2），一旦其中一个 channel 有数据，就进行处理。这种方式非常适用于处理多个 channel 的情况。

结语

通过本文，我们深入了解了 Golang 中的并发编程，包括 goroutine、channel 以及一些常见的并发模式。并发编程使得 Golang 在处理高并发任务时表现出色，开发者可以通过合理使用并发特性来提高程序性能。

希望读者通过本文的学习，能更好地应用 Golang 中的并发编程，构建高效、稳定的软件系统。