How to log messages asynchronously to avoid blocking in Go?

In Go, you can log messages asynchronously to avoid blocking by using a combination of goroutines, channels, and a logging package. Here's an example of how you can achieve this:

package main

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

var logChannel = make(chan string, 100)
var wg sync.WaitGroup

func main() {
	// Set the logger to use a file
	file, err := os.OpenFile("log.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()
	log.SetOutput(file)

	// Start a goroutine to log messages asynchronously
	wg.Add(1)
	go logger()

	// Log messages in the main goroutine
	logChannel <- "Message 1"
	logChannel <- "Message 2"
	logChannel <- "Message 3"

	// Wait for the logger goroutine to finish
	close(logChannel)
	wg.Wait()
}

func logger() {
	// Iterate over the log channel and log messages
	for msg := range logChannel {
		log.Println(msg)
	}
	wg.Done()
}

In this example, we create a buffered channel called logChannel to store log messages. We also initialize a sync.WaitGroup to ensure that the logger goroutine finishes before the program terminates.

The main goroutine starts the logger goroutine by calling go logger(). Then, it logs messages by sending them to logChannel. Since logChannel has a buffer size of 100, sending messages won't block unless the buffer is full.

The logger goroutine continuously reads from logChannel in a loop and logs the messages using the logging package's Println function. When the main goroutine finishes sending all the messages, it closes logChannel to indicate that no more messages will be sent. The logger goroutine detects this condition using the for msg := range logChannel construct and exits the loop. Finally, it calls wg.Done() to signal that it has finished.

By using this approach, logging messages doesn't block the main goroutine, allowing your program to continue its execution smoothly.