在 Go 并发编程中，有时我们需要保证特定操作的原子性，例如，防止多个 Goroutine 的打印输出混杂在一起。 很多人可能会尝试使用 runtime.LockOSThread() 和 runtime.UnlockOSThread() 来实现，但这种方法通常无法达到预期的效果。 本文将探讨为什么这种方法会失效，并提供更合适的解决方案。
正如上面摘要所说，直接使用runtime.LockOSThread()和runtime.UnlockOSThread()并不能保证多个Goroutine之间的打印输出顺序。这是因为它们主要用于将 Goroutine 绑定到特定的操作系统线程，主要目的是为了与某些需要线程亲和性的 C 库进行交互，而非控制 Goroutine 的执行顺序。
为什么 runtime.LockOSThread() 和 runtime.UnlockOSThread() 不适用于原子性输出？
runtime.LockOSThread() 将 Goroutine 绑定到一个操作系统线程，这意味着该 Goroutine 将始终在该线程上执行，直到调用 runtime.UnlockOSThread() 解除绑定。 然而，这并不意味着其他 Goroutine 不能在其他线程上执行，因此打印输出仍然可能交错。
正确的解决方案：序列化打印任务
为了保证原子性输出，我们需要对打印操作进行序列化，确保同一时刻只有一个 Goroutine 可以执行打印任务。以下是两种常用的方法：
1. 使用互斥锁（Mutex）
可以使用 sync.Mutex 来保护打印操作。 每个 Goroutine 在执行打印操作之前，需要先获取锁，完成打印后释放锁。
import (
"fmt"
"sync"
)
var printMutex sync.Mutex
func printSomething(message string) {
printMutex.Lock()
defer printMutex.Unlock() // 确保在函数退出时释放锁
fmt.Println(message)
}
func routine(id int) {
for i := 0; i < 5; i++ {
printSomething(fmt.Sprintf("Routine %d: Message %d", id, i))
}
}
func main() {
var wg sync.WaitGroup
for i := 1; i <= 2; i++ {
wg.Add(1)
go func(id int) {
defer wg.Done()
routine(id)
}(i)
}
wg.Wait()
}注意事项：
- 使用互斥锁需要小心，避免死锁。如果多个 Goroutine 相互等待对方释放锁，就会发生死锁。
- 对于复杂的程序，互斥锁可能会引入性能瓶颈。
2. 使用通道（Channel）
更优雅的方式是使用通道来传递打印任务。 创建一个专门负责打印的 Goroutine (printer)，其他 Goroutine 将需要打印的内容发送到该通道，printer Goroutine 接收任务并按顺序打印。
import (
"fmt"
"sync"
)
func printer(tasks <-chan string) {
for s := range tasks {
fmt.Println(s)
}
}
func someAgent(id int, tasks chan<- string, wg *sync.WaitGroup) {
defer wg.Done()
for i := 0; i < 5; i++ {
printUnit := fmt.Sprintf("Agent %d: Message %d", id, i)
tasks <- printUnit
}
}
func main() {
tasks := make(chan string, 10) // 创建一个带缓冲的通道，避免阻塞
var wg sync.WaitGroup
go printer(tasks) // 启动打印 Goroutine
for i := 1; i <= 2; i++ {
wg.Add(1)
go someAgent(i, tasks, &wg)
}
wg.Wait()
close(tasks) // 关闭通道，通知 printer Goroutine 任务完成
}优点：
- 避免死锁：因为 Goroutine 之间通过通道传递数据，不存在相互等待锁的情况。
- 解耦：打印逻辑与业务逻辑分离，代码更清晰。
- 易于扩展：可以轻松添加更多的打印任务。
注意事项：
- 需要合理设置通道的容量，避免阻塞。
- 在所有任务完成后，需要关闭通道，通知 printer Goroutine 退出。
总结
在 Go 并发编程中，要保证原子性输出，不能依赖 runtime.LockOSThread() 和 runtime.UnlockOSThread()。 更有效的方法是使用互斥锁或通道来序列化打印任务。 其中，使用通道的方式更加优雅，可以避免死锁，并提高代码的可维护性。 根据实际情况选择合适的解决方案，可以有效地解决并发环境下的原子性问题。
