[C++] Utilizzo di sem_post e sem_wait in ambiente Linux

[nik600]

Ciao a tutti

scusatemi non è che c'è qualche buon'anima in grado di rinfrescarmi la memoria?

è tutto il giorno che sto impazzendo su 4 righe di codice ma non mi riesce di sincronizzare 2 thread tramite semafori!!!

Posto il codice d'esempio, ho 2 thread che fanno un ciclo di 10 ognuno all'interno del ciclo attendo per un periodo diciamo random... mi aspetterei di ottenre un'output del tipo:

print_messagesB
print_messagesA
print_messagesB
print_messagesA
print_messagesB
print_messagesA
print_messagesB
print_messagesA

invece ho:

print_messagesB
print_messagesB
print_messagesB
print_messagesB
print_messagesB
print_messagesB
print_messagesB
print_messagesB
print_messagesB
print_messagesB
print_messagesA
print_messagesA
print_messagesA
print_messagesA
print_messagesA
print_messagesA
print_messagesA
print_messagesA
print_messagesA
print_messagesA

Questo è il codice: (comilo con: g++ test-thread.cc -lpthread)

#include <iostream>
#include <unistd.h>
#include <time.h>
#include <stdlib.h>
#include <semaphore.h>
#include <pthread.h>    /* POSIX Threads */

using namespace std;

void *print_messagesA ( void *ptr );
void *print_messagesB ( void *ptr );

typedef struct str_thdata
{
    int value;
    sem_t *mutex;
} thdata;


int main()
{
	pthread_t thread1, thread2;  /* thread variables */
	thdata data1, data2;         /* structs to be passed to threads */

	data1.value=1;
	data2.value=2;

	sem_t mutex;
	data1.mutex=&mutex;
	data2.mutex=&mutex;

	/*
	 * inizializzo il semaforo
	 */
	sem_init(&mutex, 0,0);
    pthread_create (&thread1, NULL,print_messagesA, (void *) &data1);
    pthread_create (&thread2, NULL,print_messagesB, (void *) &data2);

    /*
     * avvio a caso uno dei processi
     */
	sem_post(&mutex);

	pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

	return 0;
}


void *print_messagesA ( void *ptr ){

	thdata* param=(thdata*)ptr;
	int value;

	for(int i=0;i<10;i++){
		// attendo uno sblocco
		sem_wait(param->mutex);
		cout << "print_messagesA"<<endl;
		// attendo un periodo casuale
		usleep(rand()/1000);
		// sblocco
		sem_post(param->mutex);
	}
	pthread_exit(0);
}

void *print_messagesB ( void *ptr ){

	thdata* param=(thdata*)ptr;
	int value;

	for(int i=0;i<10;i++){
		// attendo uno sblocco
		sem_wait(param->mutex);
		cout << "print_messagesB"<<endl;
		// attendo un periodo casuale
		usleep(rand()/1000);
		// sblocco
		sem_post(param->mutex);

	}
	pthread_exit(0);
}

Dove sto sbagliando?

Grazie a tutti

[nik600]

ho scoperto.... stavo facendo una cavolata.

se può interessare a qualcuno questo è il codice corretto... ovviamente dovevo usare 2 semafori, e fare in modo che un processo sbloccasse l'altro...

Ciao

#include <iostream>
#include <unistd.h>
#include <time.h>
#include <stdlib.h>
#include <semaphore.h>
#include <pthread.h>    /* POSIX Threads */

using namespace std;

void *print_messagesA ( void *ptr );
void *print_messagesB ( void *ptr );

typedef struct str_thdata
{
    sem_t *mutexA;
    sem_t *mutexB;
} thdata;


int main()
{
	pthread_t thread1, thread2;  /* thread variables */
	thdata data;         /* structs to be passed to threads */

	sem_t mutex_1;
	sem_t mutex_2;
	data.mutexA=&mutex_1;
	data.mutexB=&mutex_2;

	/*
	 * inizializzo il semaforo
	 */
	sem_init(&mutex_1, 0,0);
	sem_init(&mutex_2, 0,0);

    pthread_create (&thread1, NULL,print_messagesA, (void *) &data);
    pthread_create (&thread2, NULL,print_messagesB, (void *) &data);

	// faccio partire A
	sem_post(&mutex_1);

	pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

	return 0;
}


void *print_messagesA ( void *ptr ){

	thdata* param=(thdata*)ptr;
	int value;

	for(int i=0;i<10;i++){
		// attendo uno sblocco
		sem_wait(param->mutexA);
		cout << "print_messagesA"<<endl;
		// attendo un periodo casuale
		usleep(rand()/1000);
		// sblocco B
		sem_post(param->mutexB);
	}
	pthread_exit(0);
}

void *print_messagesB ( void *ptr ){

	thdata* param=(thdata*)ptr;
	int value;

	for(int i=0;i<10;i++){
		// attendo uno sblocco
		sem_wait(param->mutexB);
		cout << "print_messagesB"<<endl;
		// attendo un periodo casuale
		usleep(rand()/1000);
		// sblocco
		sem_post(param->mutexA);

	}
	pthread_exit(0);
}