Thread: reader/writer problem using semaphores

I am working on writting 2 programs, the first was using the algorithm provided to me which basically blocks the writter out as long as there are readers. That wasn't much of a problem. I then wanted to change it to allow the writter to gain access without changing the delay of the current algorithm so I creating a semaphore q basically like a que to allow the writter in and it seems to work however I'm a little confused on what I did and was hoping someone could help me- I believe I created q to allow the writter in after all readers are done reading but every now and then it will let the writter in while there is still a reader and I thought by gaining exclusive access it shouldn't. Anyways if you don't mind taking a look at my code and any suggestions would be helpful. keep in mind the only thing I added from my original was sem q

Code:

#include <pthread.h>
#include <semaphore.h>
#include <stdio.h>
#include <unistd.h>

#define MAXTHREAD 4  /* define # readers */


void access_database();		/* prototypes */
void non_access_database();	

void* reader(void*);
void* writer(void*);

sem_t mutex;	/* controls access to rc */
sem_t db;	/* controls access to db */
sem_t q;		/* establish que */
int rc = 0;		/* number of processes reading or wanting to */
int main()
{
    pthread_t readers[MAXTHREAD],writerTh;
    int index;
    int ids[MAXTHREAD];	e readers and initialize mutex, q and db-set them to 1 */
    sem_init(&mutex,0,1);
    sem_init(&db,0,1);
   sem_init (&q,0,1);
    for(index = 0; index < MAXTHREAD; index ++)	
    {
	ids[index]=index+1;								/* create readers and error check */
	if(pthread_create(&readers[index],0,reader,&ids[index])!=0){
	perror("Cannot create reader!");
    exit(1);							
        }
    }
    if(pthread_create(&writerTh,0,writer,0)!=0){
	perror("Cannot create writer");		/* create writers and error check */
	exit(1);
    }
	
    pthread_join(writerTh,0);	
    sem_destroy(&mutex);
    sem_destroy(&db);
	sem_destroy (&q);
    return 0;
}

void* reader(void*arg)			/* readers function to read */
{
    int index = *(int*)arg;
    while(1){
	sem_wait(&q);
	sem_wait(&mutex);
	rc++;
	if(rc == 1) sem_wait(&db);
	sem_post(&mutex);
	
	access_database();
	sem_post (&q);
    printf("Thread %d reading\n",index);
	sleep(index);
	sem_wait(&mutex);
	rc--;
	if(rc == 0) sem_post(&db);
	sem_post(&mutex);	
	non_access_database();
	    }
    return 0;
}
;
void* writer(void*arg)		/* writer's function to write */
{
    while(1){
	non_access_database();
	sem_wait (&q);
	sem_wait(&db);
	
	access_database();	
	sem_post (&q);
	printf("Writer is now writing...Number of readers: %d\n",rc);
	sleep(1);
	sem_post(&db);
    }
    return 0;
}

void access_database()
{

}


void non_access_database()
{

I haven't been able to find the issue with this code. It works fine for me (though under Cygwin).

Here's a version that uses one semaphore (I think it's a little bit easier to analyze):

Code:

#include <pthread.h>
#include <sched.h>
#include <semaphore.h>
#include <stdio.h>
#include <unistd.h>

#define MAXTHREAD 10  /* define # readers */


void access_database();		/* prototypes */
void non_access_database();	

void* reader(void*);
void* writer(void*);

sem_t q;		/* establish que */
int rc = 0;		/* number of processes reading or wanting to */
int wc = 0;
int write_request = 0;

int main()
{
    pthread_t readers[MAXTHREAD],writerTh;
    int index;
    int ids[MAXTHREAD];	/* readers and initialize mutex, q and db-set them to 1 */
    sem_init (&q,0,1);
    for(index = 0; index < MAXTHREAD; index ++)	
    {
        ids[index]=index+1;								/* create readers and error check */
        if(pthread_create(&readers[index],0,reader,&ids[index])!=0){
            perror("Cannot create reader!");
            exit(1);							
        }
    }
    if(pthread_create(&writerTh,0,writer,0)!=0){
        perror("Cannot create writer");		/* create writers and error check */
        exit(1);
    }

    pthread_join(writerTh,0);	
    sem_destroy (&q);
    return 0;
}

void* reader(void*arg)			/* readers function to read */
{
    int index = *(int*)arg;
    int can_read;
    while(1){
        can_read = 1;

        sem_wait(&q);
        if(wc == 0 && write_request == 0)  rc++;
        else                               can_read = 0;
        sem_post(&q);

        if(can_read) {
            access_database();
            printf("Thread %d reading\n", index);
            sleep(index);

            sem_wait(&q);
            rc--;
            sem_post(&q);
        }

        sched_yield();
    }
    return 0;
}
;
void* writer(void*arg)		/* writer's function to write */
{
    int can_write;
    while(1){
        can_write = 1;
        non_access_database();

        sem_wait (&q);
        if(rc == 0)   wc++;
        else          { can_write = 0; write_request = 1; }
        sem_post(&q);

        if(can_write) {
            access_database();	
            printf("Writer is now writing...Number of readers: %d\n",rc);

            sleep(3);

            sem_wait(&q);
            wc--;
            write_request = 0;
            sem_post(&q);
        }

        sched_yield();
    }
    return 0;
}

void access_database()
{

}


void non_access_database()
{

}

I understand my code works. That isn't the problem. I guess I was just wondering why with my code does the reader still have access when the writter is writing sometimes it will say # of readers 1. I thought once the writter got access the reader was out. As far as writting using 3 semaphores that is the way the algorithm was given to us. I agree your is alot easier to understand. Before creating &q I just had &db and &mutex but it starved the writter so I was wondering when I created &q the way its written is it creating a que of some sort to enable the writter in because the writter gains access.

Originally Posted by jalex39

I understand my code works. That isn't the problem. I guess I was just wondering why with my code does the reader still have access when the writter is writing sometimes it will say # of readers 1. I thought once the writter got access the reader was out. As far as writting using 3 semaphores that is the way the algorithm was given to us. I agree your is alot easier to understand. Before creating &q I just had &db and &mutex but it starved the writter so I was wondering when I created &q the way its written is it creating a que of some sort to enable the writter in because the writter gains access.

That's what I meant by "it works". I was unable to get the program to print out anything other than zero for the number of reads in progress from the write thread (under Cygwin though).