引言

Go语言（Golang）自2009年由Google发布以来，凭借其简洁的语法、高效的并发处理模型和强大的性能，迅速成为开发者们的新宠。特别是在并发编程领域，Go语言的原生支持使其在高并发和分布式系统中表现出色。本文将带你从入门到实战，深入了解如何使用Go语言实现高效并发编程。

一、Go语言并发编程基础

1.1 并发与并行的区别

在开始学习Go语言的并发编程之前，我们需要明确并发（Concurrency）和并行（Parallelism）的概念：

  • 并发：指多个任务在同一时间段内交替执行，但并非同时执行。
  • 并行：指多个任务在同一时刻同时执行。

Go语言通过goroutine和channel提供了强大的并发编程支持。

1.2 Goroutine：轻量级线程

goroutine是Go语言中轻量级的执行单元，类似于线程，但更加轻量。它可以与其他goroutine并发执行，且创建和销毁的成本远低于传统线程。

package main

import (
	"fmt"
	"time"
)

func sayHello() {
	for i := 0; i < 5; i++ {
		fmt.Println("Hello")
		time.Sleep(time.Millisecond * 500)
	}
}

func sayWorld() {
	for i := 0; i < 5; i++ {
		fmt.Println("World")
		time.Sleep(time.Millisecond * 500)
	}
}

func main() {
	go sayHello() // 创建一个新的goroutine执行sayHello
	go sayWorld() // 创建一个新的goroutine执行sayWorld

	time.Sleep(time.Second * 3) // 等待goroutine执行完毕
}

1.3 Channel：Goroutine之间的通信

channel是Go语言中用于在goroutine之间传递数据的特殊类型。通过channel，可以实现goroutine之间的同步和通信。

package main

import (
	"fmt"
)

func sum(a, b int, ch chan int) {
	result := a + b
	ch <- result // 将结果发送到channel
}

func main() {
	ch := make(chan int) // 创建一个int类型的channel

	go sum(1, 2, ch) // 创建一个新的goroutine执行sum
	go sum(3, 4, ch) // 创建另一个新的goroutine执行sum

	result1 := <-ch // 从channel中读取结果
	result2 := <-ch // 从channel中读取另一个结果

	fmt.Println(result1, result2)
}

二、进阶并发编程技巧

2.1 使用WaitGroup同步goroutine

在实际应用中，我们经常需要等待多个goroutine执行完毕后再继续执行后续代码。sync.WaitGroup提供了这种同步机制。

package main

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

func worker(id int, wg *sync.WaitGroup) {
	defer wg.Done() // 完成时通知WaitGroup
	fmt.Printf("Worker %d starting\n", id)
	time.Sleep(time.Second)
	fmt.Printf("Worker %d done\n", id)
}

func main() {
	var wg sync.WaitGroup

	for i := 1; i <= 5; i++ {
		wg.Add(1) // 增加等待的goroutine数量
		go worker(i, &wg)
	}

	wg.Wait() // 等待所有goroutine执行完毕
	fmt.Println("All workers done")
}

2.2 使用Mutex保护共享资源

在并发程序中，多个goroutine可能会同时访问共享资源，导致数据竞态。sync.Mutex可以用来保护共享资源。

package main

import (
	"fmt"
	"sync"
)

var count int
var mutex sync.Mutex

func increment(wg *sync.WaitGroup) {
	defer wg.Done()
	mutex.Lock()   // 锁定资源
	count++        // 访问共享资源
	mutex.Unlock() // 解锁资源
}

func main() {
	var wg sync.WaitGroup

	for i := 0; i < 1000; i++ {
		wg.Add(1)
		go increment(&wg)
	}

	wg.Wait()
	fmt.Println("Final count:", count)
}

2.3 使用RWMutex优化读写操作

sync.RWMutex是读写互斥锁，允许多个goroutine同时读取共享资源，但只允许一个goroutine写入。

package main

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

var value int
var rwMutex sync.RWMutex

func readValue(id int) {
	rwMutex.RLock() // 获取读锁
	fmt.Printf("Reader %d: Value is %d\n", id, value)
	rwMutex.RUnlock() // 释放读锁
}

func writeValue(id int, val int) {
	rwMutex.Lock() // 获取写锁
	value = val
	fmt.Printf("Writer %d: Value set to %d\n", id, val)
	rwMutex.Unlock() // 释放写锁
}

func main() {
	var wg sync.WaitGroup

	// 启动多个读操作
	for i := 0; i < 5; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			readValue(id)
		}(i)
	}

	// 启动写操作
	wg.Add(1)
	go func(id int) {
		defer wg.Done()
		writeValue(id, 42)
	}(1)

	wg.Wait()
}

三、实战案例：并发HTTP服务器

3.1 创建基本的HTTP服务器

package main

import (
	"fmt"
	"net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Hello, %s!", r.URL.Path[1:])
}

func main() {
	http.HandleFunc("/", handler)
	http.ListenAndServe(":8080", nil)
}

3.2 处理并发请求

在上述服务器中，每个请求都会在一个新的goroutine中处理，天然支持并发。

package main

import (
	"fmt"
	"net/http"
	"sync"
	"time"
)

var mutex sync.Mutex
var count int

func handler(w http.ResponseWriter, r *http.Request) {
	mutex.Lock()
	count++
	fmt.Fprintf(w, "Request count: %d", count)
	mutex.Unlock()

	time.Sleep(time.Second) // 模拟耗时操作
}

func main() {
	http.HandleFunc("/", handler)
	http.ListenAndServe(":8080", nil)
}

四、总结

Go语言以其简洁、高效的并发处理能力，成为现代编程的理想选择。通过goroutine和channel，我们可以轻松实现高效的并发编程。本文从基础概念到实战案例，详细介绍了Go语言并发编程的各个方面，希望能帮助你快速掌握这一强大工具。

无论是初学者还是资深开发者，Go语言的并发编程都值得深入学习和应用。希望你在未来的项目中，能够充分利用Go语言的并发特性，打造出高性能、高可靠性的应用程序。