Golang异步协程调用中Logger阻塞问题解决方案

在异步协程中使用同步Logger确实会导致阻塞问题。以下是几种解决方案：

方案1：使用带缓冲的通道实现异步日志

type AsyncLogger struct {
    logger *log.Logger
    ch     chan string
}

func NewAsyncLogger(logFile string) *AsyncLogger {
    file, err := os.OpenFile(logFile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
    if err != nil {
        log.Fatal(err)
    }
    
    logger := log.New(file, "Custom Log", log.LstdFlags)
    al := &AsyncLogger{
        logger: logger,
        ch:     make(chan string, 1000), // 缓冲大小根据需求调整
    }
    
    go al.process()
    return al
}

func (al *AsyncLogger) process() {
    for msg := range al.ch {
        al.logger.Println(msg)
    }
}

func (al *AsyncLogger) Log(msg string) {
    select {
    case al.ch <- msg:
        // 成功写入通道
    default:
        // 通道满时的处理策略，例如丢弃或写入备用日志
        fmt.Println("Log buffer full, dropping message:", msg)
    }
}

func (al *AsyncLogger) Close() {
    close(al.ch)
}

// 使用示例
func main() {
    logger := NewAsyncLogger("logfile.log")
    defer logger.Close()
    
    go DoSomething(user.Filename, logger)
}

方案2：使用sync.Pool减少锁竞争

type BufferedLogger struct {
    logger *log.Logger
    mu     sync.Mutex
    pool   sync.Pool
}

func NewBufferedLogger(logFile string) *BufferedLogger {
    file, err := os.OpenFile(logFile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
    if err != nil {
        log.Fatal(err)
    }
    
    logger := log.New(file, "Custom Log", log.LstdFlags)
    
    return &BufferedLogger{
        logger: logger,
        pool: sync.Pool{
            New: func() interface{} {
                return &bytes.Buffer{}
            },
        },
    }
}

func (bl *BufferedLogger) Log(format string, args ...interface{}) {
    go func() {
        buf := bl.pool.Get().(*bytes.Buffer)
        buf.Reset()
        defer bl.pool.Put(buf)
        
        fmt.Fprintf(buf, format, args...)
        
        bl.mu.Lock()
        bl.logger.Println(buf.String())
        bl.mu.Unlock()
    }()
}

// 使用示例
func DoSomething(filename string, logger *BufferedLogger) {
    logger.Log("Processing file: %s", filename)
}

方案3：使用现有的异步日志库

// 使用zerolog示例
import "github.com/rs/zerolog"

func SetupAsyncLogger() zerolog.Logger {
    file, err := os.OpenFile("logfile.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
    if err != nil {
        log.Fatal(err)
    }
    
    // 创建异步writer
    asyncWriter := zerolog.AsyncWriter(file)
    
    return zerolog.New(asyncWriter).With().
        Timestamp().
        Str("service", "myapp").
        Logger()
}

// 使用示例
func main() {
    logger := SetupAsyncLogger()
    
    go func() {
        logger.Info().Str("filename", user.Filename).Msg("Processing file")
    }()
}

方案4：批量写入优化

type BatchLogger struct {
    logger     *log.Logger
    batchSize  int
    batch      []string
    mu         sync.Mutex
    flushTimer *time.Ticker
}

func NewBatchLogger(logFile string, batchSize int, flushInterval time.Duration) *BatchLogger {
    file, err := os.OpenFile(logFile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
    if err != nil {
        log.Fatal(err)
    }
    
    logger := log.New(file, "Custom Log", log.LstdFlags)
    
    bl := &BatchLogger{
        logger:     logger,
        batchSize:  batchSize,
        batch:      make([]string, 0, batchSize),
        flushTimer: time.NewTicker(flushInterval),
    }
    
    go bl.autoFlush()
    return bl
}

func (bl *BatchLogger) Log(msg string) {
    bl.mu.Lock()
    bl.batch = append(bl.batch, msg)
    
    if len(bl.batch) >= bl.batchSize {
        bl.flush()
    }
    bl.mu.Unlock()
}

func (bl *BatchLogger) flush() {
    if len(bl.batch) == 0 {
        return
    }
    
    var sb strings.Builder
    for _, msg := range bl.batch {
        sb.WriteString(msg)
        sb.WriteString("\n")
    }
    
    bl.logger.Print(sb.String())
    bl.batch = bl.batch[:0]
}

func (bl *BatchLogger) autoFlush() {
    for range bl.flushTimer.C {
        bl.mu.Lock()
        bl.flush()
        bl.mu.Unlock()
    }
}

func (bl *BatchLogger) Close() {
    bl.flushTimer.Stop()
    bl.mu.Lock()
    bl.flush()
    bl.mu.Unlock()
}

选择哪种方案取决于具体需求：

• 方案1适合需要完全异步且不丢失日志的场景
• 方案2适合高并发但允许少量锁竞争的场景
• 方案3适合希望使用成熟解决方案的场景
• 方案4适合需要减少磁盘I/O次数的场景