在 Golang 里，日志库通常都是线程安全的，也就是说，多个 goroutine 之间共享同一个日志实例，一般不会出问题。不过，有些场景下，你还是得留个心眼——日志操作如果触及了共享资源，比如文件句柄或数据库连接，就有可能引发竞态条件，甚至导致数据错乱。下面几个实战经验，能帮你把这些并发隐患掐死在摇篮里。

1. 用 sync.Mutex 或 sync.RWMutex 保护共享资源 —— 如果你的日志记录需要访问某个共享资源（比如写同一个文件、操作同一个数据库连接），那就必须加锁。用互斥锁（sync.Mutex）或者读写锁（sync.RWMutex）都能保证同一时刻只有一个 goroutine 在操作资源，避免冲突。

import (
    "log"
    "sync"
)

var mu sync.Mutex

func logWithMutex(message string) {
    mu.Lock()
    defer mu.Unlock()
    log.Println(message)
}

2. 利用 sync.Once 确保初始化只执行一次 —— 有些初始化工作（比如日志记录器的配置、打开日志文件）只需要在程序启动时做一次，但多个 goroutine 可能同时触发。这时候 sync.Once 就是救星，它保证传入的函数只会被调用一次，不管有多少 goroutine 同时调用。

import (
    "log"
    "sync"
)

var once sync.Once

func initializeLogger() {
    // 初始化日志记录器
}

func getLogger() *log.Logger {
    once.Do(initializeLogger)
    return &log.Logger{}
}

3. 通过 channel 把日志消息丢给一个专门的 goroutine 处理 —— 这是最优雅的解法之一。你完全不用操心锁的问题，只需要创建一个带缓冲的 channel，把日志消息扔进去，再让一个专门的 goroutine 从 channel 里接收并写入日志文件。这样，主 goroutine 只管发消息，写日志的职责完全交给后台 worker，天然实现了串行化。

import (
    "log"
    "os"
    "sync"
)

type LogEntry struct {
    Message string
}

func loggerWorker(entries chan LogEntry, wg *sync.WaitGroup) {
    defer wg.Done()
    logFile, err := os.OpenFile("logfile.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
    if err != nil {
        log.Fatal(err)
    }
    defer logFile.Close()
    logger := log.New(logFile, "", log.LstdFlags)
    for entry := range entries {
        logger.Println(entry.Message)
    }
}

func main() {
    var wg sync.WaitGroup
    entryChan := make(chan LogEntry, 100)
    wg.Add(1)
    go loggerWorker(entryChan, &wg)

    // 在程序中使用entryChan发送日志消息
    entryChan <- LogEntry{Message: "Hello, World!"}
    close(entryChan)
    wg.Wait()
}

说到底，Golang 自带的日志库虽然线程安全，但实际项目中如果涉及共享资源或复杂的并发场景，还是得根据情况再加一层防护。互斥锁、sync.Once 和 channel 这三种手段，基本能覆盖大部分并发日志写入的坑，选哪种取决于你的具体架构和性能要求。记住：日志本身是调试和监控的基石，别让它成了并发问题的导火索。

《夸克》非常好用的免费AI浏览器

下载APP查看