Dans certains programmes, il est nécessaire de définir plusieurs mutex qui sont utilisés par différents threads pour gérer l'accès à des variables partagées. Considérons un programme qui utilise trois variables globales et est découpé en plusieurs threads.

long a=5;   // variable globale partagée
long b=7;   // variable globale partagée
long c=9;   // variable globale partagée

pthread_mutex_t x; // variable globale associée à a
pthread_mutex_t y; // variable globale associée à b
pthread_mutex_t z; // variable globale associée à c


void update(int * val1, int * val2, pthread_mutex_t * mutex1, pthread_mutex_t * mutex2) {

    err=pthread_mutex_lock(mutex1);
    if(err!=0)
        error(err,"pthread_mutex_lock");
    err=pthread_mutex_lock(mutex2);
    if(err!=0)
        error(err,"pthread_mutex_lock");

    // mise à jour val1
    // mise à jour val2

    err=pthread_mutex_unlock(mutex1);
    if(err!=0)
        error(err,"pthread_mutex_unlock");

    err=pthread_mutex_unlock(mutex2);
    if(err!=0)
        error(err,"pthread_mutex_unlock");

}

Ce programme utilise plusieurs threads qui modifient les variables a, b et c. Parmi les fragments de code ci-dessous qui utilisent plusieurs threads, lesquels sont corrects ?

// thread A

update(&a,&b,&x,&y);
update(&a,&b,&x,&y);

// thread B

update(&b,&a,&y,&x);
update(&a,&c,&x,&z);

// thread A

update(&a,&b,&x,&y);
update(&a,&c,&x,&z);

// thread B

update(&b,&c,&y,&z);
update(&a,&c,&x,&z);

// thread A

update(&a,&b,&x,&y);
update(&b,&c,&y,&z);

// thread B

update(&b,&c,&y,&z);
update(&a,&c,&x,&z);

// thread A

update(&a,&b,&x,&y);
update(&c,&a,&z,&x);

// thread B

update(&b,&c,&y,&z);
update(&a,&c,&x,&z);

// thread A

update(&a,&b,&x,&y);
update(&a,&c,&x,&z);

// thread B

update(&b,&c,&y,&z);
update(&c,&a,&z,&x);