高性能应用中使用Golang的log.Println是否合适？

高性能应用中使用Golang的log.Println是否合适？ 我正在开发一个高性能应用程序，该程序将通过网络承受高负载，同时还需要实现日志记录（到文本文件）。

是使用一个缓冲区配合单独的 goroutine 缓慢地将缓冲区内容写入文件更好，还是 log.Println（写入文件）已经优化得足够好，无需这样做？

2 回复

查看 log.Println 的实现，我发现它只是委托给 fmt.Sprintln，并最终调用 (*log.Logger).Output，而后者仅调用记录器配置的输出上的 Write 方法（见此处）。这里似乎没有任何形式的优化。如果底层的 io.Writer 实现没有对其写入操作进行缓冲，那么在进行大量日志记录时，这可能会成为瓶颈。还需注意，*log.Logger 有一个 sync.Mutex 来确保写入操作的原子性，因此一次只能写入一条日志消息。

你可以尝试使用 (*log.Logger).SetOutput 将日志输出设置为一个 *bufio.Writer，这应该能让大多数日志操作更快地完成，但是你必须确保调用 (*bufio.Writer).Flush，以便所有日志消息实际上都被刷新到底层的写入器。也许需要将其放在 defer 语句中，以防发生恐慌。

一个单独的 goroutine 缓慢地将缓冲区内容排空到文件

你打算如何实现这一点？你或许可以使用 (*log.Logger).SetOutput 将输出设置为例如一个 *bytes.Buffer，但是之后你如何通知另一个 goroutine 去刷新缓冲区呢？也许你可以包装 (*bytes.Buffer).Write 方法，在其中检查缓冲区容量，并使用例如一个通道来通知写入 goroutine 刷新缓冲区，但那样你还必须等待刷新完成。我认为这比 *bufio.Writer 方案并没有带来太多好处，除了允许填满缓冲区的最后一个 goroutine 在写入 goroutine 实际刷新缓冲区时继续执行。然而，来自任何 goroutine 对任何日志函数的下一次调用都将阻塞，直到那个写入 goroutine 完成刷新。

如果你的请求量很大，并且每个请求有很多日志事件，也许你可以使用单独的 *log.Logger 实例，每个实例有独立的（可能是缓冲的）输出。这会导致生成单独的文件，这可能是个问题也可能不是，但写入文件的性能将不会受到一个 *log.Logger 的互斥锁或底层写入器的瓶颈限制。

更多关于高性能应用中使用Golang的log.Println是否合适？的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


在高性能应用中直接使用 log.Println 写入文件通常不是最佳选择，因为标准库的日志包默认使用同步写入，每次调用都会触发系统调用和磁盘I/O，这会成为性能瓶颈。

对于高负载场景，建议使用缓冲写入配合单独的 goroutine。以下是实现方案：

package main

import (
    "bufio"
    "os"
    "sync"
    "time"
)

type AsyncLogger struct {
    logChan chan string
    writer  *bufio.Writer
    file    *os.File
    wg      sync.WaitGroup
}

func NewAsyncLogger(filename string) (*AsyncLogger, error) {
    file, err := os.OpenFile(filename, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
    if err != nil {
        return nil, err
    }

    logger := &AsyncLogger{
        logChan: make(chan string, 10000), // 缓冲通道
        writer:  bufio.NewWriterSize(file, 8192), // 8KB缓冲
        file:    file,
    }

    logger.wg.Add(1)
    go logger.processLogs()
    
    return logger, nil
}

func (l *AsyncLogger) Log(msg string) {
    select {
    case l.logChan <- msg:
    default:
        // 通道满时丢弃日志或使用备用策略
    }
}

func (l *AsyncLogger) processLogs() {
    defer l.wg.Done()
    
    flushTicker := time.NewTicker(1 * time.Second)
    defer flushTicker.Stop()
    
    for {
        select {
        case msg, ok := <-l.logChan:
            if !ok {
                l.writer.Flush()
                return
            }
            l.writer.WriteString(msg + "\n")
            
        case <-flushTicker.C:
            l.writer.Flush()
        }
    }
}

func (l *AsyncLogger) Close() {
    close(l.logChan)
    l.wg.Wait()
    l.file.Close()
}

// 使用示例
func main() {
    logger, err := NewAsyncLogger("app.log")
    if err != nil {
        panic(err)
    }
    defer logger.Close()
    
    // 高并发日志写入
    for i := 0; i < 1000000; i++ {
        logger.Log("Log entry")
    }
}

这个实现提供了：

  1. 缓冲通道避免阻塞调用方
  2. 缓冲写入减少系统调用
  3. 定期刷新确保日志持久化
  4. 优雅关闭确保所有日志被写入

对于生产环境，可以考虑使用成熟的日志库如 zap 或 zerolog，它们已经实现了高性能的异步日志记录。

回到顶部