golang并发编程核心是goroutine和channel。1. goroutine通过go关键字启动轻量级线程；2. channel用于数据传递和同步，使用make(chan type)创建；3. 使用sync.mutex保护共享资源，sync.waitgroup等待goroutine完成；4. 避免goroutine泄漏需确保正常退出，结合context和select控制生命周期；5. channel应在发送端关闭，接收端检查关闭状态；6. 根据需求选择worker pool、pipeline、fan-in/fan-out或futures等并发模式；7. 调试可使用pprof、race detector、日志和调试器等工具辅助分析和排查问题。掌握这些要点有助于高效编写和维护并发程序。
Golang的并发编程核心在于goroutine和channel，它们提供了一种高效且易于理解的方式来处理并发任务。简单来说，就是用
go关键字启动轻量级线程，并通过channel进行数据传递和同步。
解决方案
要在Golang中实现并发编程，你需要掌握以下几个关键点：
立即学习“go语言免费学习笔记（深入）”；
-
Goroutine的启动： 使用
go
关键字启动一个函数或方法，它会在一个新的goroutine中执行。例如：
package main import ( "fmt" "time" ) func say(s string) { for i := 0; i < 5; i++ { time.Sleep(100 * time.Millisecond) fmt.Println(s) } } func main() { go say("world") say("hello") }在这个例子中，
say("world")将在一个新的goroutine中执行，而say("hello")在主goroutine中执行。 -
Channel的使用： Channel是goroutine之间通信的管道。 你可以使用
make(chan Type)
创建一个channel，其中Type
是channel中传递的数据类型。package main import "fmt" func sum(s []int, c chan int) { sum := 0 for _, v := range s { sum += v } c <- sum // 将sum发送到channel c } func main() { s := []int{7, 2, 8, -9, 4, 0} c := make(chan int) go sum(s[:len(s)/2], c) go sum(s[len(s)/2:], c) x, y := <-c, <-c // 从channel c接收 fmt.Println(x, y, x+y) }这个例子展示了如何使用channel在goroutine之间传递数据。注意，从channel接收数据会阻塞，直到有数据可用。
-
同步机制： 除了channel，还可以使用
sync
包提供的同步原语，如Mutex
和WaitGroup
。Mutex
用于保护共享资源，防止竞争条件。WaitGroup
用于等待一组goroutine完成。
package main import ( "fmt" "sync" "time" ) var counter int var mutex sync.Mutex func increment() { for i := 0; i < 1000; i++ { mutex.Lock() counter++ mutex.Unlock() time.Sleep(time.Millisecond) // 模拟耗时操作 } } func main() { var wg sync.WaitGroup wg.Add(2) go func() { defer wg.Done() increment() }() go func() { defer wg.Done() increment() }() wg.Wait() fmt.Println("Counter:", counter) }这个例子展示了如何使用
Mutex
保护共享变量counter
，以及如何使用WaitGroup
等待两个goroutine完成。
Goroutine泄漏如何避免？
Goroutine泄漏指的是goroutine启动后，由于某种原因无法正常结束，导致资源占用。 避免Goroutine泄漏的关键在于确保每个goroutine最终都能退出。
-
使用
select
和context
：select
语句可以让你同时监听多个channel，而context
可以用来控制goroutine的生命周期。package main import ( "context" "fmt" "time" ) func worker(ctx context.Context, id int, result chan<- string) { defer fmt.Println("Worker", id, "exiting") for { select { case <-ctx.Done(): fmt.Println("Worker", id, "cancelled") return case <-time.After(time.Second): result <- fmt.Sprintf("Worker %d: Task completed", id) return } } } func main() { ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) defer cancel() // 确保cancel被调用，释放资源 result := make(chan string, 1) go worker(ctx, 1, result) select { case res := <-result: fmt.Println(res) case <-ctx.Done(): fmt.Println("Main: Timeout reached") } time.Sleep(time.Second) // 等待worker退出 }在这个例子中，
context.WithTimeout
创建了一个带有超时时间的context。 如果context被取消或超时，worker goroutine将退出。 -
总是关闭channel： 如果一个goroutine向channel发送数据，而没有接收者，或者接收者已经退出，可能会导致goroutine阻塞。 因此，发送者应该在完成发送后关闭channel。 接收者应该检查channel是否已经关闭。
package main import ( "fmt" "time" ) func producer(c chan int) { defer close(c) // 确保channel被关闭 for i := 0; i < 5; i++ { c <- i time.Sleep(time.Millisecond * 100) } } func consumer(c chan int) { for i := range c { // 使用range循环接收数据，直到channel关闭 fmt.Println(i) } fmt.Println("Consumer exiting") } func main() { c := make(chan int) go producer(c) go consumer(c) time.Sleep(time.Second) }在这个例子中，
producer
在完成发送后关闭了channelc
。consumer
使用range
循环接收数据，直到channel关闭。
如何选择合适的并发模式？
选择合适的并发模式取决于你的具体需求。 常见的并发模式包括：
Worker Pool： 创建一组goroutine（worker）来处理任务。 适用于需要处理大量独立任务的场景。
Pipeline： 将任务分解成一系列阶段，每个阶段由一个或多个goroutine处理。 适用于需要顺序处理数据的场景。
Fan-in/Fan-out： Fan-out是将任务分发给多个goroutine处理，Fan-in是将多个goroutine的结果合并到一个channel中。 适用于需要并行处理数据的场景。
Futures/Promises： 用于异步执行任务，并在稍后获取结果。 适用于需要非阻塞地执行任务的场景。
例如，如果要实现一个Web服务器，可以使用Worker Pool来处理并发请求。 如果要实现一个数据处理管道，可以使用Pipeline模式。
如何调试并发程序？
调试并发程序比调试单线程程序更困难，因为并发程序的状态是不确定的。 一些常用的调试技巧包括：
使用
go tool pprof
：pprof
可以用来分析程序的CPU和内存使用情况，帮助你找到性能瓶颈。-
使用
race detector
：race detector
可以用来检测数据竞争。 启用race detector
的方法是在运行程序时加上-race
标志。go run -race main.go
使用日志： 在关键代码处添加日志，可以帮助你了解程序的执行流程。
使用调试器： 可以使用
delve
等调试器来调试并发程序。
调试并发程序需要耐心和技巧。 熟悉常用的调试工具和技巧，可以帮助你更快地找到问题并解决问题。 另外，编写清晰、简洁的代码，并进行充分的测试，也是避免并发问题的关键。
