在C语言中实现双缓冲技术

Question

所以我有一个非常高的数据采集速率，达到了16MB/s。我从设备文件中读取4MB的数据到缓冲区，然后进行处理。然而，这种写入再读取的方法对于该项目来说太慢了。我想在C语言中实现双缓冲区。

为了简化我的双缓冲区的想法，我决定不包括从设备文件中读取的步骤。我创建了一个C程序，生成了两个单独的线程readThread和writeThread。我让readThread调用我的swap函数来交换缓冲区的指针。

这种实现很糟糕，因为我在Mutex之外使用了共享内存。我实际上有点尴尬发布它，但至少可以让你了解我试图做什么。然而，我似乎无法想出一种实际的方法来同时读取和写入到不同的缓冲区，然后在两个线程完成读取和写入后调用交换函数。

请问是否有可能实现双缓冲区，并给我一个如何使用信号控制线程读写的想法？

请注意，readToBuff（愚蠢的名称，我知道）和writeToBuff目前实际上没有做任何事情，它们只是空函数。

以下是我的代码：

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

pthread_t writeThread;
pthread_t readThread;
pthread_mutex_t buffer_mutex;

char buff1[4], buff2[4];

struct mutex_shared {
    int stillReading, stillWriting, run_not_over;
    char *writeBuff, *readBuff;
} SHARED;

void *writeToBuff(void *idk) {
    while(!SHARED.run_not_over) {
        SHARED.stillWriting = 1;
        for(int i = 0; i < 4; i++) {
        }
        SHARED.stillWriting = 0;
        while(SHARED.stillReading){};
    }    
    printf("hello from write\n");
    return NULL;
}

void *readToBuff(void *idk) {
    while(!SHARED.run_not_over) {
        SHARED.stillReading = 1;
        for(int i = 0; i < 4; i++) {
        }
        while(SHARED.stillWriting){};
        swap(writeThread,readThread);
    }

    printf("hello from read");
    return NULL;
}

void swap(char **a, char **b){
    pthread_mutex_lock(&buffer_mutex);
        printf("in swap\n");
        char *temp = *a;
        *a = *b;
        *b = temp;
        SHARED.stillReading = 0;
        //SHARED.stillWriting = 0;
    pthread_mutex_unlock(&buffer_mutex);
}

int main() {
    SHARED.writeBuff = buff1;
    SHARED.readBuff = buff2;
    printf("buff1 address %p\n", (void*) &buff1);
    printf("buff2 address %p\n", (void*) &buff2);

    printf("writeBuff address its pointing to %p\n", SHARED.writeBuff);
    printf("readBuff address its pointing to %p\n", SHARED.readBuff);

    swap(&SHARED.writeBuff,&SHARED.readBuff);

    printf("writeBuff address its pointing to %p\n", SHARED.writeBuff);
    printf("readBuff address its pointing to %p\n", SHARED.readBuff);

    pthread_mutex_init(&buffer_mutex,NULL);

    printf("Creating Write Thread\n");

    if (pthread_create(&writeThread, NULL, writeToBuff, NULL)) {

        printf("failed to create thread\n");
        return 1;
    }
    printf("Thread created\n");
    printf("Creating Read Thread\n");
    if(pthread_create(&readThread, NULL, readToBuff, NULL)) {
            printf("failed to create thread\n");
            return 1;
    }
    printf("Thread created\n");
    pthread_join(writeThread, NULL);
    pthread_join(readThread, NULL);
    exit(0);
}

- Michael Stumpf

---

你的编译器是否会抱怨这行代码 'swap(writeThread,readThread);'？ - london-deveoper

如果你的目标是性能，那么这个双缓冲区方案可能无法满足需求。建议查看环形缓冲区（又称为环形队列）。链接 - Perette

我同意@PeretteBarella的观点。这是高性能音频应用和其他高数据率输入源通常使用的方式。如果你必须等待读者或写者停止，那么就会有性能惩罚，并且还有锁定和信号传递的开销。 - clearlight

你正在读取大小为4MB的缓冲区？必须一次从设备中读取4MB吗？例如，您能否以64KB的块（即更小的块）从设备中读取？ - Craig Estey

为什么你要交换线程而不是缓冲区？ - MikeMB

谢谢大家的评论，我想我会研究循环缓冲区以便更容易实现。http://embedjournal.com/implementing-circular-buffer-embedded-c/ - Michael Stumpf

Answer 1

使用一对信号量似乎更容易。每个线程都有自己的信号量来指示一个缓冲区已经准备好被读取或写入，并且每个线程都有自己在循环结构体数组中的索引，每个结构体包含一个指向缓冲区和缓冲区大小的指针。对于双缓冲，循环数组只包含两个结构体。

初始状态将读取线程的信号量计数设置为 2，读取索引设置为第一个缓冲区，写线程的信号量计数设置为 0，写索引设置为第一个缓冲区。然后创建写线程，该线程将立即等待其信号量。

读取线程等待其信号量上的非零信号量计数（sem_wait），读取到缓冲区中，设置缓冲区大小，增加写线程的信号量计数（sem_post），并“前进”到循环结构体数组中的索引。

写线程等待其信号量上的非零信号量计数（sem_wait），从缓冲区中写入（使用由读取线程设置的大小），增加读取线程的信号量计数（sem_post），并“前进”到循环结构体数组中的索引。

当读取完成时，读取线程将结构体的缓冲区大小设置为零以表示读取链的结束，然后等待写线程“返回”所有缓冲区。

循环结构体数组可以包含不止两个结构体，允许更多数据嵌套。

我曾经用类似的方法进行高速数据捕获，在这种情况下，输入流速度比单个硬盘还快，因此使用了两个硬盘，并且输出在两个写线程之间交替进行。其中一个写线程操作“偶数”缓冲区，另一个操作“奇数”缓冲区。

对于 Windows，由于其具有 WaitForMultipleObjects()（几乎所有操作系统都有这个功能，除了 Posix），每个线程可以使用互斥锁和信号量，以及自己的基于链表的消息队列。互斥锁用于控制队列更新的所有权，信号量指示队列上挂起的条目数。要检索消息，单个原子 WaitForMultipleObjects() 等待互斥锁和非零信号量计数，当两者都发生时，减少信号量计数并解除线程阻塞。一个消息发送方只需要在互斥锁上等待 WaitForObject()，以更新另一个线程的消息队列，然后发布（释放）线程的信号量并释放互斥锁。这消除了线程之间的任何优先级问题。

- rcgldr