C 如何在执行某些操作之前确保其他线程已完成

我的程序由许多将数据写入缓冲区的写入线程和从共享缓冲区读取数据并输出数据的读取线程组成。我需要确保所有写线程在读线程尝试从缓冲区读取数据之前都已将数据写入缓冲区。我的直觉告诉我，我将使用信号量实现这一点，但它们对我来说真的没有多大意义。以下是我的两项职能：

void *search_thread_func(void *threadArgs)
{
printf("\n");
//pthread_mutex_lock(&mutex);
int count = 0;
int matches = 0;
int matches_this_line = 0;
int lines = 0;
int inputLines = 0;
int tid;
int *wbPtr;
//char *buffer;
char *sharedBuffer;
char *writeBuffer;
char* string;
string = ((struct st_args*)threadArgs)->string;
tid = ((struct st_args*)threadArgs)->threadId;
wbPtr = ((struct st_args*)threadArgs)->wBufPtr;
//buffer = ((struct st_args*)threadArgs)->threadBuffer;
sharedBuffer = ((struct st_args*)threadArgs)->sharedBuffer;
writeBuffer = ((struct st_args*)threadArgs)->writeBuffer;
//printf("Thread %d\n",(int)tid);
printf("Searching for %s\n", string);

//printf("%d\n", (int)sharedBuffer);
while(sharedBuffer[count] != NULL)
{
    //printf("%c", sharedBuffer[count]);
    count++;
    if(sharedBuffer[count] == '\n')
    {
        inputLines++;
    }
}

printf("\n");
//pthread_mutex_unlock(&mutex);


char *token;
char *temp = malloc(count*sizeof(char));
memcpy(temp, sharedBuffer, count);
token = strtok(temp, "\n");

while(token != NULL)
{
    printf("%s\n", token);

    char *q = strstr(token, string);
    if(q != NULL)
    {
        matches_this_line++;
        lines++;

        for(char *r = q; r != NULL; r= strstr(r+strlen(string), string))
        {
            matches++;
        }
        pthread_mutex_lock(&mutex);
        for(int j = 0; j < strlen(token); j++)
        {
            writeBuffer[*wbPtr] = token[j];
            *wbPtr = *wbPtr + 1;    
        }
        writeBuffer[*wbPtr] = '\n';
        *wbPtr = *wbPtr + 1;
        pthread_mutex_unlock(&mutex);

    }

    token = strtok(NULL, "\n");
}

printf("lines %d, matches %d\n", lines, matches);

printBuffer(writeBuffer, *wbPtr);

free(temp);
printf("\n");
}

void *write_thread_func(void *threadArgs)
{
printf("write func\n");
char *writeBuffer;
int * wbPtr;
FILE* wFP;
writeBuffer = ((struct wt_args*)threadArgs)->writeBuffer;
wFP = ((struct wt_args*)threadArgs)->wFP;
wbPtr = ((struct st_args*)threadArgs)->wBufPtr;
printf("wbPtr = %d\n", wbPtr);
printf("*wbPtr = %d\n", *wbPtr);
//printf("wb loc = %d\n", writeBuffer);

}

void*search\u thread\u func（void*threadArgs）
{
printf（“\n”）；
//pthread_mutex_lock（&mutex）；
整数计数=0；
int匹配=0；
int与这条线匹配=0；
int行=0；
int inputLines=0；
国际贸易署；
int*wbPtr；
//字符*缓冲区；
char*sharedBuffer；
char*writeBuffer；
字符*字符串；
字符串=（（struct st_args*）threadArgs）->字符串；
tid=（（struct st_args*）threadArgs）->threadId；
wbPtr=（（struct st_args*）threadArgs）->wBufPtr；
//buffer=（（struct st_args*）threadArgs）->threadBuffer；
sharedBuffer=（（struct st_args*）threadArgs）->sharedBuffer；
writeBuffer=（（struct st_args*）threadArgs）->writeBuffer；
//printf（“线程%d\n”，（int）tid）；
printf（“搜索%s\n”，字符串）；
//printf（“%d\n”，（int）sharedBuffer）；
while（sharedBuffer[count]！=NULL）
{
//printf（“%c”，sharedBuffer[count]）；
计数++；
如果（sharedBuffer[count]='\n'）
{
输入线++；
}
}
printf（“\n”）；
//pthread_mutex_unlock（&mutex）；
字符*令牌；
char*temp=malloc（count*sizeof（char））；
memcpy（临时、共享缓冲、计数）；
令牌=strtok（临时“\n”）；
while（令牌！=NULL）
{
printf（“%s\n”，标记）；
char*q=strstrstr（令牌，字符串）；
如果（q！=NULL）
{
匹配这一行++；
行++；
for（char*r=q；r！=NULL；r=strstrstr（r+strlen（string），string））
{
匹配++；
}
pthread_mutex_lock（&mutex）；
对于（int j=0；jwriteBuffer；
wFP=（（struct wt_args*）threadArgs）->wFP；
wbPtr=（（struct st_args*）threadArgs）->wBufPtr；
printf（“wbPtr=%d\n”，wbPtr）；
printf（“*wbPtr=%d\n”，*wbPtr）；
//printf（“wb loc=%d\n”，writeBuffer）；
}

---

基本上，搜索线程搜索一些数据并将其他数据写入缓冲区。我还没有实现write_thread_func对缓冲区的读取，但这非常简单。我理解互斥锁是如何工作的，但我认为这在这里不起作用，因为我需要确保write_thread_func最后执行，或者等到search_thread_func完成对缓冲区的写入。

如果数据的使用者也是处理它的线程的创建者，它可以简单地

pthread\u将它们全部连接起来，并确保它们都完成了。否则，实现这一点的规范方法是在数据结构中使用互斥体和条件变量，以及基于数据结构内容的“数据是完整的”谓词。使用者将等待条件变量，生成数据的线程将在保存互斥锁的同时更新谓词所依赖的数据后发出信号

有很多方法可以用信号量实现同样的效果（例如，让每个生产者发布一次信号量，消费者等待
N
次，其中
N
是生产者的数量），但是这种类型的设计要求消费者知道更多的细节（比如有多少生产者）这可能不需要知道。
此外，信号量是系统范围的，而不是特定于进程的，因此如果程序的多个副本正在运行，则可能会遇到问题。@user3303729:不，只有在以下情况下才会出现问题：（1）使用sysv信号量或命名的POSIX信号量；（2）无法为它们生成唯一的名称。使用匿名进程本地POSIX信号量（
sem_init
）是首选方法。