linux c 异步日志

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>

#define LOG_BUFFER_SIZE 1024
#define MAX_LOG_THREADS 4

typedef struct {
    char buffer[LOG_BUFFER_SIZE];
    size_t size;
    pthread_mutex_t lock;
} LogBuffer;

typedef struct {
    LogBuffer *log_buffer;
    pthread_t thread;
    int stop;
} LogThread;

LogBuffer g_log_buffer;
LogThread g_log_threads[MAX_LOG_THREADS];

void* log_worker(void* arg) {
    LogThread *lt = (LogThread*)arg;
    while (!lt->stop) {
        pthread_mutex_lock(&g_log_buffer.lock);
        if (g_log_buffer.size > 0) {
            // 写入日志文件
            FILE *fp = fopen("async.log", "a");
            if (fp) {
                fwrite(g_log_buffer.buffer, 1, g_log_buffer.size, fp);
                fflush(fp);
                fclose(fp);
                g_log_buffer.size = 0;
            }
        }
        pthread_mutex_unlock(&g_log_buffer.lock);
        usleep(100000); // 休眠100ms
    }
    return NULL;
}

void async_log(const char *msg) {
    pthread_mutex_lock(&g_log_buffer.lock);
    size_t len = strlen(msg);
    if (g_log_buffer.size + len >= LOG_BUFFER_SIZE) {
        // 缓冲区满，触发写入
        FILE *fp = fopen("async.log", "a");
        if (fp) {
            fwrite(g_log_buffer.buffer, 1, g_log_buffer.size, fp);
            fflush(fp);
            fclose(fp);
            g_log_buffer.size = 0;
        }
    }
    memcpy(g_log_buffer.buffer + g_log_buffer.size, msg, len);
    g_log_buffer.size += len;
    pthread_mutex_unlock(&g_log_buffer.lock);
}

int main() {
    pthread_mutex_init(&g_log_buffer.lock, NULL);
    for (int i = 0; i < MAX_LOG_THREADS; ++i) {
        g_log_threads[i].log_buffer = &g_log_buffer;
        g_log_threads[i].stop = 0;
        pthread_create(&g_log_threads[i].thread, NULL, log_worker, &g_log_threads[i]);
    }

    for (int i = 0; i < 100; ++i) {
        char msg[64];
        snprintf(msg, sizeof(msg), "Log message %d\n", i);
        async_log(msg);
    }

    sleep(2); // 等待日志线程处理

    for (int i = 0; i < MAX_LOG_THREADS; ++i) {
        g_log_threads[i].stop = 1;
        pthread_join(g_log_threads[i].thread, NULL);
    }

    pthread_mutex_destroy(&g_log_buffer.lock);
    return 0;
}