使用C语言编程时使用Tricky Deadlock

Question

I tried to make a file copier using threads and somehow, the programm locks when entering the functions. I searched a lot and I tried many things, but I simply can't find the solution. I would be glad if somebody could help me!

//gcc -o threadcopyfile threadcopyfile.c -lpthread -lrt
#include <stdio.h>
#include <pthread.h> 
#include <unistd.h> 
#include <string.h>
#include <stdlib.h>


pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; //init mutex
pthread_cond_t condRead = PTHREAD_COND_INITIALIZER; //init cond. variables
pthread_cond_t condWrite = PTHREAD_COND_INITIALIZER; //init cond. variables

int n, x = 1, i = 0, j, condition = 0;
char c;

pthread_t pRead;
pthread_t pWrite;

char ringpuffer[10000];

void *functionRead(void *argv){
    char **args = (char **) argv; //Give args the arguments from argv
    FILE* fp;
    if ((fp=fopen(args[1], "r")) == NULL){ //Open the inputfile, check if failed
        perror("fopen\n"); 
        exit(EXIT_FAILURE);
    }
    n = atoi(args[3]);
    printf("Entered functionRead\n");
    do{
        pthread_mutex_lock(&mutex); //Lock mutex
        while(condition == 1){
            pthread_cond_wait(&condRead, &mutex); //Wait for cond_signal
        }
        i = 0;
        for(i = 0; i<=n; i++){ //Put chars into the ringbuffer
            c = fgetc(fp);
            ringpuffer[i] = c;
            i++;
        }
        x++;
        printf("Hit!");
        condition = 1;
        pthread_mutex_unlock(&mutex); //Unlock mutex
        pthread_cond_signal(&condWrite); //Send signal to CondWrite
    }while ((c=fgetc(fp)) != EOF);

    if ((fclose(fp)) == EOF){ //Close the file
        perror("fclose\n"); 
        exit(EXIT_FAILURE);
    }
    return 0;
}

void *functionWrite(void *argv){
    char **args = (char **) argv;   //Give args the arguments from argv
    FILE* fp;
    if ((fp=fopen(args[2], "w")) == NULL){ //Open the outputfile, check if allowed
        perror("fopen\n"); 
        exit(EXIT_FAILURE);
    }
    n = atoi(args[3]);
    printf("Entered functionWrite\n");
    for (j = 0; j < x; j++){
        pthread_mutex_lock(&mutex); //Lock mutex
        while(condition == 0){
            pthread_cond_wait(&condWrite, &mutex); //Wait for singel from condRead
        }
        fwrite(ringpuffer, 1, n, fp); //Write to file
        printf("Hit too!");
        condition = 0;
        pthread_mutex_unlock(&mutex); //Unlock
        pthread_cond_signal(&condRead); //Send signal again to condRead
    }

    if ((fclose(fp)) == EOF){
        perror("fclose\n"); 
        exit(EXIT_FAILURE);
    }
    return EXIT_SUCCESS;
}

int main(int argc, char **argv)
{
    if (argc != 4){
        printf("Only 3 parameters allowed!\n");
        exit(EXIT_FAILURE);
    }
    printf("File to Copy: %s\nTarget: %s\nHow many chars: %s\n", argv[1], argv[2], argv[3]);

    pthread_create(&pWrite, NULL, &functionWrite, ((void *)argv)); //Create thread, threadid in pWrite, execute functionWrite, and give argv as arguments
    pthread_create(&pRead, NULL, &functionRead, ((void *)argv)); //Create thread, threadid in pRead, execute functionRead and give argv as arguments 

    printf("Threads created, file copy in progress\n");
    pthread_cond_signal(&condRead); //Unblocks the thread

    pthread_join(pRead, NULL);
    pthread_join(pWrite, NULL);
    printf("done.\n");
    return 0;
}

Answer 1

You can't use a single mutex with two condition variables like that. If a thread calls pthread_cond_signal() and relocks the mutex before the second thread wakes up, the second thread will never be able to return from pthread_cond_wait() since it can't lock the mutex.

You also don't seem to be setting condition = 1 , as both your functionRead() and functionWrite() have condition = 0 in them.

Answer 2

Your main issue is the termination condition for your writer thread - by the time the reader thread has decided to exit, it has already incremented x so the writer thread will wait another time for it... forever.

You also shouldn't be calling c = fgetc(fp) again in the termination condition of the while loop, because you end up throwing away the character that was read there. Instead, your loop that reads the buffer could be:

i = 0;
while (i < n && (c = fgetc(fp)) != EOF) { //Put chars into the ringbuffer
    ringpuffer[i] = c;
    i++;
}

At the end of this loop we know that:

• We read exactly i characters into the buffer; and
• if i < n , we have reached end-of-file and should exit.

You can use the second of these points to know when the reader thread should finish, so the overall loop looks like:

do {
    pthread_mutex_lock(&mutex); //Lock mutex
    while(condition == 1){
        pthread_cond_wait(&condRead, &mutex); //Wait for cond_signal
    }
    i = 0;
    while (i < n && (c = fgetc(fp)) != EOF) { //Put chars into the ringbuffer
        ringpuffer[i] = c;
        i++;
    }
    printf("Hit!");
    condition = 1;
    pthread_mutex_unlock(&mutex); //Unlock mutex
    pthread_cond_signal(&condWrite); //Send signal to CondWrite
} while (i == n);

To fix the actual problem with the writer thread terminating, you can use this same termination condition. However we need to keep the lock held while we test i in the writer thread, because otherwise it could race with a write to i in the reader thread. To do this, we move the unlock and lock outside the loop (this doesn't matter, because the only substantial lenght of time that the thread isn't holding the lock is while it is in pthread_cond_wait() anyway). We also use i as the number of bytes to write from the buffer, because that's where the reader thread leaves that value:

pthread_mutex_lock(&mutex); //Lock mutex
printf("Entered functionWrite\n");
do {
    while(condition == 0){
        pthread_cond_wait(&condWrite, &mutex); //Wait for singel from condRead
    }
    fwrite(ringpuffer, 1, i, fp); //Write to file
    printf("Hit too!");
    condition = 0;
    pthread_cond_signal(&condRead); //Send signal again to condRead
} while (i == n);
pthread_mutex_unlock(&mutex); //Unlock

After these changes, j and x are no longer needed.

You have a couple of other issues that I can see:

• n is set by both the writer and the reader thread, without a lock held. You can just set it in the reader thread, since the writer thread doesn't access it until the reader thread has executed once.

• The variable c should be an int , not a char . Otherwise c might never compare equal to EOF , because EOF is not necessarily in the range of char (that's why fgetc() returns int ). c can also just be local to functionRead() .

• There's no need to signal condRead in the main thread, because the reader will test condition before waiting.

But perhaps most fundamentally, I think you may have missed the point of this exercise, because although you have an array called ringpuffer you are not actually using it as a ring buffer. You aren't getting any parallelism - your design means that your threads run in lock-step. I suspect that the idea is that you should have two separate flags - buffer_empty and buffer_full - rather than a single "reading or writing" condition. Your file reader runs as long as buffer_full isn't true, and your file writer runs as long as buffer_empty isn't true, so for the portion of time that both flags are false you can have both threads running.