golang 的并发性优化技巧包括：使用 goroutine 进行并行任务处理；使用 channels 实现 goroutine 间通信；使用 goroutine pool 管理 goroutine；避免锁争用；减少内存复制。
如何优化 Golang 中的并发性和性能
Golang 以其高并发性而闻名，可并行处理多个任务，提升程序效率。以下是一些优化 Golang 并发性和性能的有效技巧：
1. 使用 Goroutine
立即学习“go语言免费学习笔记（深入）”；
Goroutine 是轻量级线程，可用于并行执行任务，避免阻塞。创建 Goroutine 有助于分散任务，充分利用多核 CPU。
package main
import (
"fmt"
"time"
)
func slowTask(id int) {
time.Sleep(1 * time.Second)
fmt.Printf("Slow task %d done\n", id)
}
func main() {
// 使用 Goroutine 并行运行慢速任务
for i := 0; i < 10; i++ {
go slowTask(i)
}
// 主线程继续执行，不会等待 Goroutine 完成
fmt.Println("Main thread continues")
}2. 使用 Channels
Channels 用于 Goroutine 之间的通信。它们允许在 Goroutine 之间发送和接收数据，从而实现分工协作。
package main
import (
"fmt"
"sync"
)
var wg sync.WaitGroup
func producer(ch chan<- int) {
for i := 0; i < 5; i++ {
ch <- i
}
wg.Done()
}
func consumer(ch <-chan int) {
for i := range ch {
fmt.Printf("Received: %d\n", i)
}
wg.Done()
}
func main() {
// 创建一个容量为 5 的 Channel
ch := make(chan int, 5)
// 启动一个 Goroutine 作为 Producer
go producer(ch)
// 启动两个 Goroutine 作为 Consumer
go consumer(ch)
go consumer(ch)
wg.Add(3)
wg.Wait()
}3. 使用 goroutine pool
Goroutine pool 是一种管理 Goroutine 的技术，可以减少创建新 Goroutine 的开销。通过重用现有的 Goroutine，可以提升性能。
package main
import (
"fmt"
"sync"
)
type Pool struct {
pool chan struct{}
wg sync.WaitGroup
}
func main() {
pool := Pool{pool: make(chan struct{}, 5)}
for i := 0; i < 10; i++ {
pool.wg.Add(1)
go func(i int) {
pool.Acquire()
fmt.Printf("Working on task %d\n", i)
pool.Release()
pool.wg.Done()
}(i)
}
pool.wg.Wait()
}
func (p *Pool) Acquire() {
p.pool <- struct{}{}
}
func (p *Pool) Release() {
<-p.pool
}4. 避免锁争用
锁争用会导致性能下降。可以通过细粒度地锁定数据结构避免这种情况，仅锁定需要保护的部分。
package main
import (
"sync"
"time"
)
var counter int
var m sync.Mutex
func increment() {
m.Lock()
counter++
m.Unlock()
}
func main() {
for i := 0; i < 100; i++ {
go increment()
}
time.Sleep(1 * time.Second)
fmt.Println("Counter:", counter)
}5. 减少内存复制
内存复制是昂贵的操作。可以通过传递指针或引用，而不是值，来避免复制。
package main
import (
"fmt"
"time"
)
func calculate(n *int) {
time.Sleep(1 * time.Second)
*n += 1
}
func main() {
num := 0
go calculate(&num)
// 主线程继续执行，不会等待 Goroutine 完成
fmt.Println("Main thread continues")
time.Sleep(2 * time.Second)
fmt.Println("Result:", num)
}通过应用这些技巧，你可以显着优化 Golang 中的并发性和性能，创建响应迅速且高效的程序。
