[C]Aiuti pre-esame Programmazione Concorrente (mutex, semafori etc..)

[stgww]

Ciao, mi devo preparare all'esame di info2 che avrei dovuto fare lo scorso semestre e dunque non ricordo quasi niente dalle lezioni:D

Apro questo thread per chiedere consigli e chiarimenti.

Ringrazio anticipatamente chiunque riesca a darmi una mano :)

Taglio parti inutili alla comprensione dell'esercizio tipo include e dichiarazioni variabili

Il primo quesito riguarda un esercizio standard in cui mi chiedono di identificare la sequenza che genera un deadlock , segno cosa non capisco nel codice (penso mi stia confondendo con i puntatori, ma ditemi voi)

void foo(int val){
pthread_mutex_lock (& mutexB);
val *= 2; //ma che significa ?
if(val > 4)
pthread_mutex_unlock (& mutexB);
}

void * thread1(void *arg){
pthread_mutex_lock (& mutexA);
foo((int)arg); //sto passando a fool il valore che ho passato nel main?
pthread_mutex_unlock (& mutexA);
if((int)arg < 2)
pthread_mutex_unlock (& mutexB);
pthread_mutex_lock (& mutexA);
printf(”Sono alla fine del thread1\n”);
pthread_mutex_unlock (& mutexA);
return NULL;
}

void * thread2(void *arg){
pthread_mutex_lock (& mutexA);
pthread_mutex_lock (& mutexB);
printf(”Sono alla fine del thread2\n”);
pthread_mutex_unlock (& mutexB);
pthread_mutex_unlock (& mutexA);
return NULL;
}

int main(int argc , char * argv []){
pthread_t th1 , th2;
pthread_create (&th1 , NULL , thread1 , (void *)2); // significa passa il valore 2 al thread 1 ? Finita li ?
pthread_create (&th2 , NULL , thread2 , NULL);
pthread_join(th1 , NULL);
pthread_join(th2 , NULL);
return 0;
}

[Cor3]

val *= 2;
singifica assegna a val il suo valore moltiplicato per 2, in pratica equivale a
val = val * 2;

Agli altri 2 dubbi ti sei risposto da solo.

[stgww]

Grazie Cor3.
Domanda sui semafori: il prof. scrive

sem_wait(...)decrementa il valore del semaforo:

–se il semaforo ha valore > 0, il thread che ha invocato la sem_wait
decrementa tale valore e prosegue nell’esecuzione

–se il semaforo ha valore ≤ 0, allora il thread che ha invocato la sem_wait
decrementa il semaforo e rimane bloccato finché il semaforo non diventa ≥ 0 (= 0),
e poi prosegue nell’esecuzione


sem_post(...)incrementa il valore del semaforo:

–il thread che ha invocata la sem_post
incrementa di un’unità il valore e prosegue nell’esecuzione
–ed eventualmente sblocca un thread accodato

Ok, ma se ad esempio il valore di sem (variabile semaforica generica) a valore -170 e l'istruzione da eseguire è una post incrementa il valore e comunque si ferma l'esecuzione perchè il valore è negativo o va avanti ?
Nel caso si bloccasse come si comporta nel caso il valore di sem fosse -1 e quindi dopo la post passerebbe a 0

Grazie




EDIT: Domanda ->
In generale tutto il blocco contenuto tra un mutex lock e un mutex unlock viene eseguito rigorosamente tutto in sequenza giusto? Ma per intenderci in una situazione tipo (tralascio la sintassi corretta per velocizzare)
mutex_lock (1)
..codice qualsiasi...(2)
mutex_unlock

sicuro il (2) viene eseguito tutto insieme ma dopo la (1) volendo può cambiare contesto e passare ad un altro thread?

E nel caso:
mutex_lock (1)
sem_wait(sem)(2)
mutex_unlock

la wait mi blocchi l'esecuzione esco fregandomene che sono sotto mutex?

Grazie