Vérifier pour voir si un pthread mutex est verrouillé ou déverrouillé (Après un thread a elle-même bloquée)

J'ai besoin de voir si un mutex est verrouillé ou déverrouillé à une instruction if donc je check comme ça...

if(mutex[id] != 2){
    /* do stuff */
}

mais quand je vérifie gcc me donne l'erreur suivante:

error: invalid operands to binary != (have 'ptherad_mutex_t' and 'int')

Alors, comment puis-je vérifier pour voir si le mutex est verrouillé ou pas?

EDIT:

Un élément clé de mon problème est que mon fils (par conception) se verrouiller à droite APRÈS avoir passé le contrôle à un autre thread. Alors, quand Un thread passe le contrôle thread B thread est verrouillé, le thread B agit de certaines choses, puis, quand le fil B est fait de débloquer thread A.

Le problème avec cela est que si le fil B tentatives de déverrouillage fil Un fil et Une n'a pas encore terminé de verrouillage lui-même, puis l'appel à débloquer est perdu de fil et d'Un reste verrouillé ce qui provoque la mort de verrouillage.

Mise à JOUR:

J'ai refait mon programme de prise de la caf de la suggestion, mais je suis toujours en cours d'exécution dans des problèmes. J'ai moulé mon programme dans la structure de la caf prévue le mieux que je peux mais je ne peux même pas dire quelle est la cause de la mort de verrouillage maintenant... j'ai créé une nouvelle question ici demander de l'aide avec mon code.

Ci-dessous est un exécutable de la version de la caf de la suggestion. J'ai fait une petite réorganisation de la fonction pour passer le fil, sans laquelle les deux enfiler un fil et b aurait été verrouillé lors de leur création, en attente d'une condition qui ne pourrait jamais changer.

#include <pthread.h>

int run_a = 0;
pthread_mutex_t lock_a = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_a = PTHREAD_COND_INITIALIZER;

int run_b = 0;
pthread_mutex_t lock_b = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_b = PTHREAD_COND_INITIALIZER;

void *a(void *);
void *b(void *);

int main(){
    int status;
    pthread_t thread_a;
    pthread_t thread_b;

    pthread_create(&thread_a, NULL, a, (void *)0);
    pthread_create(&thread_b, NULL, b, (void *)0);

    pthread_join(thread_a, (void **)&status);
    pthread_join(thread_b, (void **)&status);

}

/* thread A */
void *a(void *i){
    while (1) {
        printf("thread A is running\n");
        sleep(1);

        /* unlock thread B */
        pthread_mutex_lock(&lock_b);
            run_b = 1;
            pthread_cond_signal(&cond_b);
        pthread_mutex_unlock(&lock_b);

        /* wait for thread A to be runnable */
        pthread_mutex_lock(&lock_a);
            while (!run_a)
                pthread_cond_wait(&cond_a, &lock_a);
            run_a = 0;
        pthread_mutex_unlock(&lock_a);      
    }
}

/* thread B */
void *b(void *i){
    while (1) {
        /* wait for thread B to be runnable */
        pthread_mutex_lock(&lock_b);
            while (!run_b)
                pthread_cond_wait(&cond_b, &lock_b);
            run_b = 0;
        pthread_mutex_unlock(&lock_b);

        printf("thread B is running\n");
        sleep(1);

        /* unlock thread A */
        pthread_mutex_lock(&lock_a);
            run_a = 1;
            pthread_cond_signal(&cond_a);
        pthread_mutex_unlock(&lock_a);
    }
}

OriginalL'auteur ubiquibacon | 2010-12-06