CareerCup

int threadCount=20;
Semaphore barrierSem(0);


void barrier()
{
	barrierSem.post();
	while(threadCount)
	{
		barrierSem.wait();
		threadCount--;
	}
}


Thread1
{
	//some code
	barrier();
}

Thread2
{
	//some code;
	barrier();
}

...

Thread20
{
	//some code
	barrier();
}

Sounds like barrier, never used though

call pthread_join at that point to make it wait till the other finishes. I am confused what do they mean by reaching there. If its as simple then you can even use a semaphore check at that point which this earlier reached thread shall call with a sem_wait and the latter with sem_post.

t1.start();
t2.start();
In run method check whats the running thread if its not the one which you wanted to run first(Lets say t1).Put t2.join stmt meaning you can only run the remaining block once t2 will end the critical section.

Or just put a semaphore check.

Please correct me If i am wrong.

It seems like he is asking you to design a barrier. Here's one solution.

Initialize a semaphore called barrier with value 0. Also, have a variable num_threads, which is a count of the number of threads to be waited at the barrier. So, when a thread reaches the particular synchronization/barrier point in the code it does:

num_threads++;
if(num_threads == 2) // 2 in this case
{
for(i=0;i<2; i++)
V(barrier); // wakes up all threads blocked on the semaphore barrier..
// in this case 2
}
else
P(barrier); // block thread at this point if all threads have not reached

How abt making all threads block on a condition variables and increment a counter. If the counter is equal to #threads spawned, notify all threads. This way the last thread increments the counter and notifies all threads. Till then they will be blocked.

we can use semaphore to achieve such synchronization
initialize the semaphore value to zero
Process 1
do operations,
//sync point
signal semaphore

Process 2
do operations
wait for semaphore

sema task1;
sema task2;

in task1: in task2:
=========== ===========
wait(task2); wait(task1);

Use pthread conditian wait and condition signaling mechanism this might be the better approach.

semaphore t1(0),t2(0)

T1()
{
....
t2.signal()
t1.wait()
}

T2()
{
....
t1.signal()
t2.wait()
}

If t2 is not waiting t2.signal is lost?
Alterante solution. Start a semaphore in taken state. When the common function enters, wait on the semaphore. When 2nd thread reaches the function give the semaphore so that previous thread wakesup and continous.
int threadCount=0;
Semaphore barrierSem(0);
Mutex mu;

void barrier()
{
Mutex.lock( );
threadcount++;
Mutex.unlock( );
if(threadcount ==2)
{
barrieSem.post( );
}else if (threadcount ==1)
{
barrierSem.wait(); //1st entered thread waits here
}
}


Thread1
{
//some code
barrier();
}

Thread2
{
//some code;
barrier();
}

If t2 is not waiting t2.signal is lost?
Alterante solution. Start a semaphore in taken state. When the common function enters, wait on the semaphore. When 2nd thread reaches the function give the semaphore so that previous thread wakesup and continous.
int threadCount=0;
Semaphore barrierSem(0);
Mutex mu;

void barrier()
{
Mutex.lock( );
threadcount++;
Mutex.unlock( );
if(threadcount ==2)
{
barrieSem.post( );
}else if (threadcount ==1)
{
barrierSem.wait(); //1st entered thread waits here
}
}


Thread1
{
//some code
barrier();
}

Thread2
{
//some code;
barrier();
}

If t2 is not waiting t2.signal is lost?
Alterante solution. Start a semaphore in taken state. When the common function enters, wait on the semaphore. When 2nd thread reaches the function give the semaphore so that previous thread wakesup and continous.
int threadCount=0;
Semaphore barrierSem(0);
Mutex mu;

void barrier()
{
Mutex.lock( );
threadcount++;
Mutex.unlock( );
if(threadcount ==2)
{
barrieSem.post( );
}else if (threadcount ==1)
{
barrierSem.wait(); //1st entered thread waits here
}
}


Thread1
{
//some code
barrier();
}

Thread2
{
//some code;
barrier();
}