并发
📚 五种执行模式定义
1. 同步 (Synchronous) - 调用后等待结果返回
2. 异步 (Asynchronous) - 调用后立即返回,不等待
3. 串行 (Serial) - 任务一个接一个顺序执行
4. 并发 (Concurrency) - 多任务交替执行,逻辑上同时
5. 并行 (Parallelism) - 多任务真正同时执行,物理上同时
Goroutine (go)
创建一个额外线程执行相应内容
内存占用极小(2kb),Go的特有优势
func sayHello(name string) {
for i := 0; i < 3; i++ {
fmt.Printf("Hello %s! (%d)\n", name, i+1)
time.Sleep(100 * time.Millisecond)
}
}
func main() {
// 普通调用:同步执行
sayHello("同步")
// 加 go:异步执行
go sayHello("异步1")
go sayHello("异步2")
// 等待 goroutine 完成
time.Sleep(1 * time.Second)
}
// 可能的输出(顺序不确定):
// Hello 同步! (1)
// Hello 同步! (2)
// Hello 同步! (3)
// Hello 异步1! (1)
// Hello 异步2! (1)
// Hello 异步1! (2)
// Hello 异步2! (2)
// ...那么为什么会不同步呢?
因为Go的底层逻辑是跟一个复杂的调度器有关,因此go的执行顺序与代码内容无关
所以最后的time.Sleep就是在等待其他线程都执行完再结束主函数
那我们该怎么控制不同线程呢?这就是sync包会讲的内容
在此之前,先让我们认识一下Channel
Channel
channel就是不同线程间传输数据的通道

这就涉及到了Go的设计哲学💡:
"不要通过共享内存来通信,而要通过通信来共享内存"
这是Go并发编程的核心思想!
基本操作
// 1. 创建 channel
ch := make(chan int) // 无缓冲
buffered := make(chan int, 5) // 有缓冲(容量5)
// 2. 发送数据
ch <- 42
// 3. 接收数据
value := <-ch
// 4. 关闭 channel
close(ch)
// 5. 遍历 channel
for value := range ch {
fmt.Println(value)
}有/无缓冲
无缓冲 Channel:必须有人接收,发送才能成功
在无人接收时,Channel会阻塞当前节点(无法进行下一行内容),直到有人接收
ch := make(chan int) // 容量为0
go func() {
ch <- 42 // 会阻塞,直到有人接收
fmt.Println("发送成功")
}()
value := <-ch // 接收,上面的发送才能完成
fmt.Println("收到:", value)有缓冲 Channel:可以先放进去,后面再取
ch := make(chan int, 3) // 容量为3
// 可以连续发送3个,不会阻塞
ch <- 1
ch <- 2
ch <- 3
fmt.Println("发送了3个值")
// 后面再接收
fmt.Println(<-ch) // 1
fmt.Println(<-ch) // 2
fmt.Println(<-ch) // 3只接收/只发送
chan<- int:只能发送的channel(防止你误接收)<-chan int:只能接收的channel(防止你误发送)- 这是类型安全的保护!体现了Go"在编译期发现问题"的设计
Select
select用于同时监听多个channel,用default实现非阻塞操作
在select内部可以包含多个channel case,哪个channel先准备好,哪个case就先执行
比如:超时控制:
package main
import (
"fmt"
"time"
)
func fetchData(ch chan<- string) {
time.Sleep(2 * time.Second) // 模拟耗时操作
ch <- "数据获取成功"
}
func main() {
ch := make(chan string)
go fetchData(ch)
// 设置1秒超时
select {
case result := <-ch:
fmt.Println(result)
case <-time.After(1 * time.Second):
fmt.Println("超时!操作耗时过长")
}
}
// 输出: 超时!操作耗时过长多重监听:
package main
import (
"fmt"
"time"
)
func main() {
ch1 := make(chan string)
ch2 := make(chan string)
quit := make(chan bool)
// 1秒后发送
go func() {
time.Sleep(1 * time.Second)
ch1 <- "消息1"
}()
// 2秒后发送
go func() {
time.Sleep(2 * time.Second)
ch2 <- "消息2"
}()
// 3秒后发送退出信号
go func() {
time.Sleep(3 * time.Second)
quit <- true
}()
// 持续监听
for {
select {
case msg := <-ch1:
fmt.Println("收到:", msg)
case msg := <-ch2:
fmt.Println("收到:", msg)
case <-quit:
fmt.Println("退出!")
return
}
}
}
// 输出:
// 收到: 消息1
// 收到: 消息2
// 退出!sync包
包含多个方法控制线程:WaitGroup/Mutex/Once/RWMutex
适用场景对比:
| 场景 | 推荐方案 | 原因 |
|---|---|---|
| 传递数据 | Channel | Go 的设计哲学 |
| 等待一组任务完成 | sync.WaitGroup | 简单直接 |
| 保护共享资源 | sync.Mutex | 传统且高效 |
| 只读一次的配置 | sync.Once | 保证单次执行 |
| 高并发读多写少 | sync.RWMutex | 性能优化 |
sync.WaitGroup
可以精确等待某线程执行完毕
可以通过此方法调控go并发的执行顺序
核心方法:
var wg sync.WaitGroup // 创建WaitGroup实例
wg.Add(n) // 计数器 +n (启动 goroutine 前调用)
wg.Done() // 计数器 -1 (goroutine 结束时调用)
wg.Wait() // 阻塞,直到计数器为 0代码示例:
package main
import (
"fmt"
"sync"
"time"
)
func worker(id int, wg *sync.WaitGroup) {
defer wg.Done() // 完成时通知 WaitGroup(推荐用defer)
fmt.Printf("Worker %d 开始工作\n", id)
time.Sleep(time.Second)
fmt.Printf("Worker %d 完成工作\n", id)
}
func main() {
var wg sync.WaitGroup
// 启动5个 worker
for i := 1; i <= 5; i++ {
wg.Add(1) // 计数器 +1
go worker(i, &wg)
}
wg.Wait() // 阻塞,直到计数器归零
fmt.Println("所有 worker 完成!")
}
// 输出(顺序可能不同):
// Worker 1 开始工作
// Worker 5 开始工作
// Worker 2 开始工作
// Worker 3 开始工作
// Worker 4 开始工作
// Worker 1 完成工作
// Worker 3 完成工作
// ...
// 所有 worker 完成!sync.Mutex
当多个 goroutine 同时修改同一个变量会出现竞态条件(race condition),导致结果错误!
于是,我们可以使用 sync.Mutex 互斥锁保护共享资源
sync.Mutex 可以保护数据同时只被一项进程读写:
核心方法:
var mu sync.Mutex
mu.Lock() // 加锁(阻塞,直到获得锁)
mu.Unlock() // 解锁基本使用:
package main
import (
"fmt"
"sync"
)
type SafeCounter struct {
mu sync.Mutex
count int
}
func (c *SafeCounter) Increment() {
c.mu.Lock() // 加锁
c.count++ // 安全修改
c.mu.Unlock() // 解锁
}
func (c *SafeCounter) Value() int {
c.mu.Lock() // 读取也要加锁
defer c.mu.Unlock() // defer 确保一定会解锁
return c.count
}
func main() {
counter := SafeCounter{}
var wg sync.WaitGroup
// 1000 个 goroutine 同时累加
for i := 0; i < 1000; i++ {
wg.Add(1)
go func() {
defer wg.Done()
counter.Increment()
}()
}
wg.Wait()
fmt.Println("最终值:", counter.Value()) // 总是 1000(正确!)
}sync.RWMutex
我们知道sync.Mutex 不区分读和写,即使只是读取数据也要加锁,效率低
于是我们可以使用RWMutex 允许多个 goroutine 同时读,但写时独占
核心方法:
var mu sync.RWMutex
// 读操作
mu.RLock() // 加读锁(可以有多个)
mu.RUnlock() // 释放读锁
// 写操作
mu.Lock() // 加写锁(独占)
mu.Unlock() // 释放写锁基本使用:
package main
import (
"fmt"
"sync"
"time"
)
type Config struct {
mu sync.RWMutex
data map[string]string
}
// 读配置(多个协程可以同时读)
func (c *Config) Get(key string) string {
c.mu.RLock()
defer c.mu.RUnlock()
return c.data[key]
}
// 写配置(独占,其他人不能读也不能写)
func (c *Config) Set(key, value string) {
c.mu.Lock()
defer c.mu.Unlock()
c.data[key] = value
fmt.Printf("更新配置: %s = %s\n", key, value)
}
func main() {
config := Config{
data: map[string]string{
"host": "localhost",
"port": "8080",
},
}
var wg sync.WaitGroup
// 10 个协程读取配置(可以并发)
for i := 0; i < 10; i++ {
wg.Add(1)
go func(id int) {
defer wg.Done()
host := config.Get("host")
fmt.Printf("协程 %d 读取: %s\n", id, host)
time.Sleep(time.Millisecond * 100)
}(i)
}
// 1 个协程更新配置
wg.Add(1)
go func() {
defer wg.Done()
time.Sleep(time.Millisecond * 50)
config.Set("host", "127.0.0.1")
}()
wg.Wait()
}sync.Once
某些初始化操作(如加载配置、建立连接)只能执行一次
于是我们可以使用sync.Once 保证函数只执行一次,即使被多次调用也只执行一次
核心方法:
var once sync.Once
once.Do(func() {
// 这个函数只会执行一次
// 即使 Do 被多次调用
})基本使用:
package main
import (
"fmt"
"sync"
)
var (
instance *Database
once sync.Once
)
type Database struct {
Connection string
}
// 单例模式:只初始化一次
func GetDatabase() *Database {
once.Do(func() {
fmt.Println("初始化数据库连接...")
instance = &Database{
Connection: "localhost:5432",
}
})
return instance
}
func main() {
var wg sync.WaitGroup
// 10 个 goroutine 同时获取数据库实例
for i := 0; i < 10; i++ {
wg.Add(1)
go func(id int) {
defer wg.Done()
db := GetDatabase()
fmt.Printf("协程 %d 获得实例: %p\n", id, db)
}(i)
}
wg.Wait()
}
// 输出:
// 初始化数据库连接... (只输出一次!)
// 协程 1 获得实例: 0xc0000a4000
// 协程 2 获得实例: 0xc0000a4000 (地址相同!)
// 协程 3 获得实例: 0xc0000a4000
// ...总结


评论
留言与讨论 ↗欢迎留下想法或问题。这里承接旧站已有评论。
正在加载评论…