当前位置：首页 > news >正文

编程语言：Go语言并发编程实战

news 2026/5/27 6:07:54

编程语言：Go语言并发编程实战

大家好，我是欧阳瑞（Rich Own）。今天想和大家聊聊Go语言并发编程这个重要话题。作为一个全栈开发者，Go语言以其出色的并发支持而闻名。今天就来分享一下Go语言并发编程的实战经验。

Go并发概述

Go并发模型

Goroutine → 轻量级线程 Channel → 通道通信 Select → 多路复用 Sync包 → 同步原语

并发优势

特性	说明
轻量级	每个Goroutine只需几KB栈空间
高效	多路复用减少上下文切换
简洁	语法层面支持并发

Goroutine

基本用法

package main import ( "fmt" "time" ) func sayHello(name string) { for i := 0; i < 3; i++ { fmt.Printf("Hello, %s! (%d)\n", name, i) time.Sleep(100 * time.Millisecond) } } func main() { // 启动Goroutine go sayHello("World") go sayHello("Go") // 等待Goroutine完成 time.Sleep(500 * time.Millisecond) fmt.Println("Main done") }

WaitGroup

package main import ( "fmt" "sync" "time" ) func worker(id int, wg *sync.WaitGroup) { defer wg.Done() 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 <= 3; i++ { wg.Add(1) go worker(i, &wg) } wg.Wait() fmt.Println("All workers done") }

Channel

基本用法

package main import "fmt" func producer(ch chan<- int) { for i := 0; i < 5; i++ { ch <- i fmt.Printf("Sent: %d\n", i) } close(ch) } func consumer(ch <-chan int) { for num := range ch { fmt.Printf("Received: %d\n", num) } } func main() { ch := make(chan int) go producer(ch) consumer(ch) }

带缓冲的Channel

package main import "fmt" func main() { ch := make(chan int, 3) // 缓冲大小为3 ch <- 1 ch <- 2 ch <- 3 fmt.Println(<-ch) // 1 fmt.Println(<-ch) // 2 fmt.Println(<-ch) // 3 }

Select语句

package main import ( "fmt" "time" ) func main() { ch1 := make(chan string) ch2 := make(chan string) go func() { time.Sleep(1 * time.Second) ch1 <- "from channel 1" }() go func() { time.Sleep(2 * time.Second) ch2 <- "from channel 2" }() for i := 0; i < 2; i++ { select { case msg1 := <-ch1: fmt.Println(msg1) case msg2 := <-ch2: fmt.Println(msg2) } } }

并发模式

Worker Pool

package main import ( "fmt" "sync" ) func worker(id int, jobs <-chan int, results chan<- int) { for job := range jobs { fmt.Printf("Worker %d processing job %d\n", id, job) results <- job * 2 } } func main() { jobs := make(chan int, 100) results := make(chan int, 100) // 启动3个worker for w := 1; w <= 3; w++ { go worker(w, jobs, results) } // 发送9个任务 for j := 1; j <= 9; j++ { jobs <- j } close(jobs) // 收集结果 for r := 1; r <= 9; r++ { <-results } }

Fan-Out/Fan-In

package main import ( "fmt" "sync" ) func producer(nums []int) <-chan int { out := make(chan int) go func() { for _, n := range nums { out <- n } close(out) }() return out } func square(in <-chan int) <-chan int { out := make(chan int) go func() { for n := range in { out <- n * n } close(out) }() return out } func merge(cs ...<-chan int) <-chan int { var wg sync.WaitGroup out := make(chan int) output := func(c <-chan int) { for n := range c { out <- n } wg.Done() } wg.Add(len(cs)) for _, c := range cs { go output(c) } go func() { wg.Wait() close(out) }() return out } func main() { in := producer([]int{1, 2, 3, 4}) c1 := square(in) c2 := square(in) for n := range merge(c1, c2) { fmt.Println(n) } }

最佳实践

1. 避免数据竞争

// 使用Mutex保护共享数据 var mu sync.Mutex var count int func increment() { mu.Lock() count++ mu.Unlock() }

2. 使用Context取消

package main import ( "context" "fmt" "time" ) func worker(ctx context.Context) { for { select { case <-ctx.Done(): fmt.Println("Worker cancelled") return default: fmt.Println("Working...") time.Sleep(100 * time.Millisecond) } } } func main() { ctx, cancel := context.WithCancel(context.Background()) go worker(ctx) time.Sleep(500 * time.Millisecond) cancel() time.Sleep(200 * time.Millisecond) }