How do you setup callback in reader/writer multi-threading program - c

Question

I have written a reader/writer lock implementation and what I plan to do is to setup callback for each thread. Let's say we have 3 reader threads and 3 of them have read a value X. Now a writer thread updates the value X to X+100. This should send a callback to all the 3 reader threads that the value has changed. How do we implement such a callback in the multi-threading environment in C programming language?
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<semaphore.h>
#include<stdint.h>
sem_t dbAccess;
sem_t readCountAccess;
int readCount=0;
void *Reader(void *arg);
void *Writer(void *arg);
int main(int argc, char* argv[])
{
int i=0, num_of_readers = 0, num_of_writers = 0;
//inititalizing semaphores
sem_init(&readCountAccess,0,1);
sem_init(&dbAccess,0,1);
pthread_t readers_tid[100], writer_tid[100];
num_of_readers = atoi(argv[1]);
num_of_writers = atoi(argv[2]);
for(i = 0; i < num_of_readers; i++)
{
pthread_create(&readers_tid[i], NULL , Reader, (void *) (intptr_t) i);
}
for(i = 0;i < num_of_writers; i++)
{
pthread_create(&writer_tid[i], NULL, Writer, (void *) (intptr_t) i);
}
for(i = 0; i < num_of_writers; i++)
{
pthread_join(writer_tid[i],NULL);
}
for(i = 0; i < num_of_readers; i++)
{
pthread_join(readers_tid[i], NULL);
}
sem_destroy(&dbAccess);
sem_destroy(&readCountAccess);
return 0;
}
void * Writer(void *arg)
{
sleep(1);
int temp=(intptr_t) arg;
printf("Writer %d is trying to enter into database for modifying the data\n",temp);
sem_wait(&dbAccess);
printf("Writer %d is writting into the database\n",temp);
printf("Writer %d is leaving the database\n");
sem_post(&dbAccess);
}
void *Reader(void *arg)
{
sleep(1);
int temp=(intptr_t) arg;
printf("Reader %d is trying to enter into the Database for reading the data\n",temp);
sem_wait(&readCountAccess);
readCount++;
if(readCount==1)
{
sem_wait(&dbAccess);
printf("Reader %d is reading the database\n",temp);
}
sem_post(&readCountAccess);
sem_wait(&readCountAccess);
readCount--;
if(readCount==0)
{
printf("Reader %d is leaving the database\n",temp);
sem_post(&dbAccess);
}
sem_post(&readCountAccess);
}

Answer 1

I can see 2 possible approaches:
1. Let the readers call a function when they'd like to be notified. The writer would have to mark something per-reader thread to say they have to call your CB on the shared variable. This would be my preferred approach, as I'd design readers to know when they need these updates.
2. Signal the readers to have them execute some code from a signal handler. You can use SIG_USR1/2 for that, and add some additional marking somewhere to know what changed and what to call. This is less clean, obviously, but I imagine would be more handy when these threads are created by 3rd party and you cannot control what they're doing.
HTH
EDIT
I forgot another important thing - if you're only updating a POD variable (int, etc) you may use the method 1 with a seqlock and a local copy per reader thread. This way every reader would know did the value change.
Another consideration is do you need readers to know only the last value or do they need to respond to every single change? if you need to respond to every change you can use a lock free queue, one per reader, and have the writer push into every one of them.