面试题：C语言优化Linux消息队列发送与接收性能

优化策略

内存管理：

预先分配足够的内存空间，避免在消息发送和接收过程中频繁进行内存分配和释放操作。对于固定大小的消息，可以使用静态数组；对于可变大小的消息，使用内存池技术。
例如，使用内存池时，初始化内存池函数如下：

#include <stdlib.h>
#include <stdio.h>

// 内存块结构体
typedef struct MemBlock {
    struct MemBlock* next;
} MemBlock;

// 内存池结构体
typedef struct MemPool {
    MemBlock* freeList;
    size_t blockSize;
} MemPool;

// 初始化内存池
MemPool* createMemPool(size_t blockSize, int numBlocks) {
    MemPool* pool = (MemPool*)malloc(sizeof(MemPool));
    if (!pool) {
        return NULL;
    }
    pool->blockSize = blockSize;
    pool->freeList = NULL;
    for (int i = 0; i < numBlocks; i++) {
        MemBlock* block = (MemBlock*)malloc(blockSize);
        block->next = pool->freeList;
        pool->freeList = block;
    }
    return pool;
}

// 从内存池获取内存块
void* getBlock(MemPool* pool) {
    if (!pool->freeList) {
        return NULL;
    }
    MemBlock* block = pool->freeList;
    pool->freeList = block->next;
    return block;
}

// 归还内存块到内存池
void returnBlock(MemPool* pool, void* block) {
    ((MemBlock*)block)->next = pool->freeList;
    pool->freeList = (MemBlock*)block;
}

多线程处理：

可以使用多线程来并行处理消息的发送和接收。为了避免竞态条件，需要使用互斥锁（pthread_mutex_t）和条件变量（pthread_cond_t）来同步线程。
例如，发送线程和接收线程的框架代码如下：

#include <pthread.h>
#include <mqueue.h>
#include <stdio.h>
#include <string.h>

mqd_t mq;
pthread_mutex_t mqMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t mqCond = PTHREAD_COND_INITIALIZER;

void* sendThread(void* arg) {
    char message[1024];
    while (1) {
        // 准备消息
        sprintf(message, "Message from send thread at %ld", (long)pthread_self());
        pthread_mutex_lock(&mqMutex);
        mq_send(mq, message, strlen(message) + 1, 0);
        pthread_cond_signal(&mqCond);
        pthread_mutex_unlock(&mqMutex);
        // 模拟其他工作
        sleep(1);
    }
    return NULL;
}

void* receiveThread(void* arg) {
    char buffer[1024];
    while (1) {
        pthread_mutex_lock(&mqMutex);
        while (mq_receive(mq, buffer, sizeof(buffer), NULL) == -1) {
            pthread_cond_wait(&mqCond, &mqMutex);
        }
        printf("Received: %s\n", buffer);
        pthread_mutex_unlock(&mqMutex);
    }
    return NULL;
}

消息缓存机制：

在应用层实现消息缓存，例如使用环形缓冲区。这样可以减少对内核消息队列的直接操作次数，提高效率。
环形缓冲区的简单实现如下：

#include <stdio.h>
#include <stdlib.h>

// 环形缓冲区结构体
typedef struct CircularBuffer {
    char* buffer;
    size_t head;
    size_t tail;
    size_t capacity;
} CircularBuffer;

// 初始化环形缓冲区
CircularBuffer* createCircularBuffer(size_t capacity) {
    CircularBuffer* cb = (CircularBuffer*)malloc(sizeof(CircularBuffer));
    if (!cb) {
        return NULL;
    }
    cb->buffer = (char*)malloc(capacity);
    if (!cb->buffer) {
        free(cb);
        return NULL;
    }
    cb->head = 0;
    cb->tail = 0;
    cb->capacity = capacity;
    return cb;
}

// 向环形缓冲区写入数据
int writeToCircularBuffer(CircularBuffer* cb, const char* data, size_t length) {
    size_t available = (cb->capacity - cb->tail + cb->head) % cb->capacity;
    if (length > available) {
        return -1;
    }
    size_t part1 = cb->capacity - cb->tail;
    if (length <= part1) {
        memcpy(cb->buffer + cb->tail, data, length);
        cb->tail = (cb->tail + length) % cb->capacity;
    } else {
        memcpy(cb->buffer + cb->tail, data, part1);
        memcpy(cb->buffer, data + part1, length - part1);
        cb->tail = length - part1;
    }
    return 0;
}

// 从环形缓冲区读取数据
int readFromCircularBuffer(CircularBuffer* cb, char* data, size_t length) {
    size_t available = (cb->tail - cb->head + cb->capacity) % cb->capacity;
    if (length > available) {
        return -1;
    }
    size_t part1 = cb->capacity - cb->head;
    if (length <= part1) {
        memcpy(data, cb->buffer + cb->head, length);
        cb->head = (cb->head + length) % cb->capacity;
    } else {
        memcpy(data, cb->buffer + cb->head, part1);
        memcpy(data + part1, cb->buffer, length - part1);
        cb->head = length - part1;
    }
    return 0;
}

关键代码示例

初始化消息队列：

struct mq_attr attr;
attr.mq_maxmsg = 100;
attr.mq_msgsize = 1024;
mqd_t mq = mq_open("/myqueue", O_CREAT | O_RDWR, 0666, &attr);
if (mq == (mqd_t)-1) {
    perror("mq_open");
    return -1;
}

发送消息（优化后结合内存池和多线程）：

MemPool* sendPool = createMemPool(1024, 100);
void* msgBlock = getBlock(sendPool);
if (msgBlock) {
    char* message = (char*)msgBlock;
    sprintf(message, "Optimized message");
    pthread_mutex_lock(&mqMutex);
    mq_send(mq, message, strlen(message) + 1, 0);
    pthread_cond_signal(&mqCond);
    pthread_mutex_unlock(&mqMutex);
    returnBlock(sendPool, msgBlock);
}

接收消息（优化后结合多线程和环形缓冲区）：

CircularBuffer* recvBuffer = createCircularBuffer(1024 * 10);
pthread_mutex_lock(&mqMutex);
while (mq_receive(mq, buffer, sizeof(buffer), NULL) == -1) {
    pthread_cond_wait(&mqCond, &mqMutex);
}
writeToCircularBuffer(recvBuffer, buffer, strlen(buffer) + 1);
pthread_mutex_unlock(&mqMutex);

性能对比分析思路

测试指标：
- 吞吐量：单位时间内成功发送或接收的消息数量。可以通过记录在一段时间内发送或接收的消息总数，然后除以时间得到。
- 延迟：从消息准备好到被成功发送或接收的时间间隔。可以使用高精度定时器（如clock_gettime）来记录消息准备时间和发送/接收完成时间，计算差值。
测试方法：
- 优化前：编写一个简单的单线程程序，使用基本的mq_send和mq_receive函数，在一个循环中不断发送和接收消息，记录上述测试指标。
- 优化后：启动多线程程序，结合内存管理和消息缓存机制，同样在一个循环中发送和接收消息，记录相应指标。
分析：
- 对比优化前后的吞吐量和延迟指标。如果优化后的吞吐量显著提高，延迟显著降低，说明优化策略有效。例如，如果使用多线程后吞吐量提升了数倍，这表明多线程并行处理起到了作用；如果使用内存池后延迟降低，说明减少内存分配开销带来了性能提升。同时，也可以分析不同优化策略之间的组合效果，找出最优的优化方案。

星途面试题库

面试题：C语言优化Linux消息队列发送与接收性能

知识考点

面试题答案

优化策略

关键代码示例

性能对比分析思路