Implementing a Semaphore - c++

Question

I have the following code below. I want only half of the threads to enter the threadedfunction at a time. How do I create a Semaphore to block the other processes? And how would I go about unblocking the previously blocked processes whenever the threads have finished using the function?
#include <iostream>
#include <unistd.h>
#include <sys/wait.h>
#include <pthread.h>
using namespace std;
#define NUM_THREADS 4
long int sharedcount;
pthread_mutex_t count_mutex;
//Function that will be run by multiple threads
//Needs to return a void pointer and if it takes arguments
//it needs to be a void pointer
void *ThreadedFunction(void *threadid)
{
int success;
long id = (long)threadid;
//Lock mutex preventing the other threads from ru nning
success = pthread_mutex_lock( &count_mutex );
cout << "Thread " << id << " beginning.\n";
for(int i = 0; i < 100000000; i++)
sharedcount++;
cout << "Thread " << id << " exiting.\n";
cout << sharedcount << endl;
//Unlock the mutex after the thread has finished running
pthread_mutex_unlock( &count_mutex );
//Kill the thread
pthread_exit(NULL);
}
int main ()
{
//Initialize mutex
pthread_mutex_init(&count_mutex, NULL);
//Create an array of threads
pthread_t threads[NUM_THREADS];
int rc;
int i;
sharedcount = 0;
for( i=0; i < NUM_THREADS; i++ )
{
cout << "main() : creating thread, " << i << endl;
//Create thread by storing it in a location in the array. Call the
//function for the threads to run inside. And pass the argument (if any).
//If no arguments pass NULL
rc = pthread_create(&threads[i], NULL, ThreadedFunction, (void *)i);
if (rc)
{
cout << "Error:unable to create thread," << rc << endl;
exit(-1);
}
}
//Have main thread wait for all other threads to stop running.
for(i = 0; i < NUM_THREADS; i++)
pthread_join(threads[i], NULL);
//cout << sharedcount << endl;
pthread_exit(NULL);
}

Answer 1

What you could do is use a counting semaphore (as opposed to a binary semaphore). A counting semaphore has an initial value greater than 1, allowing for multiple threads to call "wait" on the semaphore and not have those threads actually blocked and put in the semaphore queue.
What I would have done in your case is initialize a semaphore in the main function with an initial value of NUM_THREADS/2. Then I would insert a line at the beginning of threadedFunction where I do a wait(semaphore) and a line at the end of the function where you do a signal(semaphore). This way, when a thread is about to exit the function, it signals a thread that was blocked after having called wait on the semaphore and it lets this thread in.
Hope this helps.