面试题：C语言共享内存跨平台及性能调优

Question

在实际项目中，可能需要将基于Linux C语言共享内存的程序移植到其他类Unix系统甚至Windows系统。请阐述在不同操作系统下共享内存实现的差异及你所采取的跨平台解决方案。另外，假设在高并发场景下，共享内存的访问性能出现瓶颈，从系统层面和代码层面，你会如何进行性能调优？请详细说明思路和关键代码片段。

Answer 1

不同操作系统下共享内存实现的差异

1. Linux
   • 使用shmget、shmat、shmdt和shmctl等系统调用进行共享内存的创建、映射、分离和控制。例如：

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>
#include <stdlib.h>

#define SHM_SIZE 1024

int main() {
    key_t key;
    int shmid;
    char *shm, *s;

    // 创建一个唯一的键
    key = ftok(".", 'a');
    if (key == -1) {
        perror("ftok");
        exit(1);
    }

    // 创建共享内存段
    shmid = shmget(key, SHM_SIZE, IPC_CREAT | 0666);
    if (shmid == -1) {
        perror("shmget");
        exit(1);
    }

    // 映射共享内存段到进程地址空间
    shm = (char *)shmat(shmid, NULL, 0);
    if (shm == (void *)-1) {
        perror("shmat");
        exit(1);
    }

    // 使用共享内存
    s = shm;
    *s = 'H';
    s++;
    *s = 'e';
    s++;
    *s = 'l';
    s++;
    *s = 'l';
    s++;
    *s = 'o';
    s++;
    *s = '\0';

    // 分离共享内存段
    if (shmdt(shm) == -1) {
        perror("shmdt");
        exit(1);
    }

    // 删除共享内存段
    if (shmctl(shmid, IPC_RMID, NULL) == -1) {
        perror("shmctl");
        exit(1);
    }

    return 0;
}

2. 类Unix系统（如FreeBSD、Solaris等）
   • 与Linux类似，也使用shmget等相关系统调用，但在细节上可能存在差异，如某些系统对共享内存大小的限制、权限设置的细微差别等。例如，在FreeBSD中，共享内存的创建和使用方式与Linux基本相同，但在共享内存的清理方面，可能需要注意一些系统特定的规则。
3. Windows
   • Windows没有与Linux共享内存完全对应的概念，而是使用文件映射（File Mapping）来实现类似功能。通过CreateFileMapping、MapViewOfFile和UnmapViewOfFile等函数实现。例如：

#include <windows.h>
#include <stdio.h>

#define SHM_SIZE 1024

int main() {
    HANDLE hFile, hMapFile;
    LPCTSTR pBuf;

    // 创建一个文件句柄
    hFile = CreateFile(TEXT("test.dat"),
                       GENERIC_READ | GENERIC_WRITE,
                       0,
                       NULL,
                       CREATE_ALWAYS,
                       FILE_ATTRIBUTE_NORMAL,
                       NULL);
    if (hFile == INVALID_HANDLE_VALUE) {
        printf("CreateFile error: %d\n", GetLastError());
        return 1;
    }

    // 创建文件映射对象
    hMapFile = CreateFileMapping(hFile,
                                 NULL,
                                 PAGE_READWRITE,
                                 0,
                                 SHM_SIZE,
                                 TEXT("SharedMemory"));
    if (hMapFile == NULL) {
        printf("CreateFileMapping error: %d\n", GetLastError());
        CloseHandle(hFile);
        return 1;
    }

    // 映射文件视图到进程地址空间
    pBuf = (LPTSTR)MapViewOfFile(hMapFile,
                                 FILE_MAP_ALL_ACCESS,
                                 0,
                                 0,
                                 SHM_SIZE);
    if (pBuf == NULL) {
        printf("MapViewOfFile error: %d\n", GetLastError());
        CloseHandle(hFile);
        CloseHandle(hMapFile);
        return 1;
    }

    // 使用共享内存
    _tcscpy_s((LPTSTR)pBuf, SHM_SIZE / sizeof(TCHAR), TEXT("Hello"));

    // 取消映射视图
    if (!UnmapViewOfFile(pBuf)) {
        printf("UnmapViewOfFile error: %d\n", GetLastError());
    }

    // 关闭文件映射对象和文件句柄
    CloseHandle(hMapFile);
    CloseHandle(hFile);

    return 0;
}

跨平台解决方案

1. 封装接口
   • 定义一套统一的共享内存操作接口，如shm_create、shm_connect、shm_write、shm_read和shm_destroy等。
   • 在不同操作系统下，根据实际的系统调用实现这些接口。例如，在Linux下调用shmget等函数，在Windows下调用CreateFileMapping等函数。

#ifdef _WIN32
#include <windows.h>
// Windows下共享内存操作接口实现
void* shm_create(const char* name, size_t size) {
    HANDLE hFile, hMapFile;
    hFile = CreateFile(TEXT("test.dat"),
                       GENERIC_READ | GENERIC_WRITE,
                       0,
                       NULL,
                       CREATE_ALWAYS,
                       FILE_ATTRIBUTE_NORMAL,
                       NULL);
    if (hFile == INVALID_HANDLE_VALUE) {
        return NULL;
    }
    hMapFile = CreateFileMapping(hFile,
                                 NULL,
                                 PAGE_READWRITE,
                                 0,
                                 size,
                                 TEXT(name));
    if (hMapFile == NULL) {
        CloseHandle(hFile);
        return NULL;
    }
    CloseHandle(hFile);
    return MapViewOfFile(hMapFile,
                         FILE_MAP_ALL_ACCESS,
                         0,
                         0,
                         size);
}

void shm_destroy(void* handle) {
    UnmapViewOfFile(handle);
    // 这里假设通过某种方式获取到hMapFile并关闭，实际实现可能更复杂
    // CloseHandle(hMapFile);
}
#else
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
// Linux下共享内存操作接口实现
void* shm_create(const char* name, size_t size) {
    key_t key = ftok(name, 1);
    if (key == -1) {
        return NULL;
    }
    int shmid = shmget(key, size, IPC_CREAT | 0666);
    if (shmid == -1) {
        return NULL;
    }
    return shmat(shmid, NULL, 0);
}

void shm_destroy(void* handle) {
    shmdt(handle);
    // 这里假设通过某种方式获取到shmid并删除，实际实现可能更复杂
    // shmctl(shmid, IPC_RMID, NULL);
}
#endif

2. 条件编译
   • 使用#ifdef、#elif和#endif等预处理指令，根据不同的操作系统宏（如_WIN32、__linux__等）选择相应的代码实现。

高并发场景下共享内存访问性能瓶颈的性能调优

1. 系统层面
   • 增加内存资源：确保系统有足够的物理内存和交换空间，避免因内存不足导致的频繁换页，从而影响共享内存的访问性能。可以通过调整系统的内存分配策略，如调整swappiness参数（在Linux系统中），减少不必要的内存交换。
   • 优化内核参数：在Linux系统中，调整与共享内存相关的内核参数，如shmmax（最大共享内存段大小）和shmall（系统中总共可以使用的共享内存页数）。可以通过修改/etc/sysctl.conf文件并执行sudo sysctl -p使修改生效。例如：

shmmax = 68719476736
shmall = 4294967296

• 使用多核CPU：充分利用多核CPU的优势，将共享内存的访问任务分配到不同的CPU核心上并行处理。可以通过设置CPU亲和性（CPU Affinity），将特定的线程或进程绑定到指定的CPU核心。在Linux下，可以使用taskset命令或CPU_SET等函数来设置CPU亲和性。例如，在代码中设置当前线程的CPU亲和性：

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

int main() {
    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    CPU_SET(0, &cpuset);
    if (sched_setaffinity(0, sizeof(cpu_set_t), &cpuset) == -1) {
        perror("sched_setaffinity");
        exit(1);
    }
    // 后续代码
    return 0;
}

2. 代码层面
   • 减少锁竞争：如果使用锁来保护共享内存的访问，尽量减少锁的粒度和持有时间。可以采用读写锁（pthread_rwlock在Linux下，SRWLOCK在Windows下），对于读多写少的场景，允许多个线程同时读共享内存，只有写操作时才需要独占锁。例如，在Linux下使用读写锁：

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

pthread_rwlock_t rwlock;
int shared_data = 0;

void* read_thread(void* arg) {
    pthread_rwlock_rdlock(&rwlock);
    printf("Reader thread read data: %d\n", shared_data);
    pthread_rwlock_unlock(&rwlock);
    return NULL;
}

void* write_thread(void* arg) {
    pthread_rwlock_wrlock(&rwlock);
    shared_data++;
    printf("Writer thread updated data: %d\n", shared_data);
    pthread_rwlock_unlock(&rwlock);
    return NULL;
}

int main() {
    pthread_rwlock_init(&rwlock, NULL);

    pthread_t read_tid, write_tid;
    pthread_create(&read_tid, NULL, read_thread, NULL);
    pthread_create(&write_tid, NULL, write_thread, NULL);

    pthread_join(read_tid, NULL);
    pthread_join(write_tid, NULL);

    pthread_rwlock_destroy(&rwlock);
    return 0;
}

• 使用无锁数据结构：在一些场景下，可以使用无锁数据结构来避免锁带来的性能开销。例如，在Linux下可以使用liblfds库提供的无锁数据结构。无锁数据结构通过使用原子操作和内存屏障来确保数据的一致性和线程安全。例如，使用原子变量（std::atomic在C++11及以上）来实现简单的无锁计数器：

#include <atomic>
#include <iostream>
#include <thread>

std::atomic<int> counter(0);

void increment() {
    for (int i = 0; i < 1000000; ++i) {
        counter++;
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

    t1.join();
    t2.join();

    std::cout << "Final counter value: " << counter << std::endl;
    return 0;
}

• 优化内存访问模式：避免频繁的内存碎片，尽量按照顺序访问共享内存。可以通过预分配足够大的连续内存块，并合理组织数据结构来减少内存碎片的产生。例如，使用结构体数组而不是链表来存储数据，因为结构体数组在内存中是连续存储的，访问效率更高。同时，考虑使用缓存行对齐（Cache Line Alignment）技术，避免伪共享（False Sharing）问题，提高缓存命中率。在C++中，可以使用alignas关键字来指定对齐方式。例如：

#include <iostream>
#include <vector>

// 假设缓存行大小为64字节
alignas(64) struct Data {
    int value;
};

int main() {
    std::vector<Data> data_vector(100);
    // 对data_vector进行操作
    for (auto& d : data_vector) {
        d.value = 1;
    }
    return 0;
}