infinite loop in producer-consumer problem

Question

I'm trying to gain a better understanding of fork() and concurrency in c programming. I'm a novice, and I'm having trouble understanding the logic. I tried to make a simple producer-consumer program using fork(). basically, a producer() function should take a character from stdin, and write it to a file. At the same time, a second process runs the consumer code, which is supposed to read the last character in the file and echo it to the screen. The producer() and consumer() functions are working fine by themselves, i.e. they are doing what each are supposed to do, but the problem is in the concurrency. Here is my code:

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

FILE* fp;
//char c;

void producer(){
        char c=' ';
        while(c!='x'){
                puts("enter a char");
                c = getchar();

                while((fp = fopen("shared.txt", "at"))==NULL); //while the file is in use by another program

                fputc(c,fp);

                if(c!='\n')puts("file written to successfully");
                fclose(fp);
        }
        return;
}

char readChar(){
        char c;
        while((fp = fopen("shared.txt", "rt"))==NULL);
        fseek(fp, -1, SEEK_END);
        c = fgetc(fp);
        fclose(fp);
        return c;
}

void consumer(){
        char c;
        do{
                c = readChar();
                printf("This is the latest character supplied: %c\n", c);
        }while(c!='x');

}

int main(){
        int pid = fork(); //now we fork processes

        if(pid ==0 ){
                producer();  //the child process should run and create some text in the file
        }else{
                wait(); consumer(); 
        }
}

I tried to add wait statements after the calls to producer() and consumer() in their respective branches, but basically no matter what, the program fails to do what I want . if in main () I have

int main(){
        int pid = fork(); //now we fork processes

        if(pid ==0 ){
                producer();   //the child process should run and create some text in the file
        }else{
                consumer(); 
        }
}

I get stuck in an infinite loop. Adding wait(); after the function call in one or both branches doesn't help, because the infinite loop occurs before control passes to either wait().

If I try this:

int main(){
        int pid = fork(); //now we fork processes

        if(pid ==0 ){
                producer();   //the child process should run and create some text in the file
        }else{
               wait(); consumer(); 
        }
}

I can enter text from the stdin until I enter 'x', but then as expected the consumer reads only the last character written to the file.

Is there a way to get this to work with wait statements?

Answer 1

the problem is in the concurrency

I'd say the problem is in the (lack of) synchronization. In a producer / consumer arrangement, the producer usually has a means to signal the consumer that a new item is available for consumption, and the consumer waits for that signal before trying to consume one. Details vary from there, but they typically also include a way for the producer to signal the consumer that no more items will be forthcoming.

Your consumer does not wait for any explicit signal, and it does not use the data available to it (file length) to determine that a new item is available. On the other hand, it makes no effort to keep its own place among the items consumed, so it can easily miss items if the producer gets ahead of it. Moreover, the consumer busy-loops, performing expensive I/O operations no less, which is a very costly way to go about this.

Is there a way to get this to work with wait statements?

Only if you wanted the producer to run to completion before the consumer consumed anything. That's what wait() does: it waits for another process to terminate. In that case, you would want the consumer to just read the file from the beginning, character by character, instead of leaping straight to the end.

If you want producer and consumer to make progress concurrently, then the easiest way to go about it would be to make use of the facilities already provided to you by the system, by using a FIFO or a pipe instead of a regular file. Then the producer could just write character after character and the consumer could just read character after character, without any of this reopening and repositioning nonsense.

If you must do it with a regular file, then you could use a pair of semaphores or a mutex + condition variable to make producer and consumer take turns. Alternatively, there are various ways that the consumer could monitor the file to detect when it has changed (stat / fstat, inotify, etc.) to avoid needlessly trying to read from it, and you could combine that with it tracking its own position in that file, so as not to re-read data it has already consumed. Ideally, neither program would open the file more than once, but the producer might need to fflush after each write.