Necesito ver si un mutex está bloqueado o desbloqueado en una declaración if, así que lo verifico así ...

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

pero cuando lo reviso gcc me da el siguiente error:

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

Entonces, ¿cómo puedo verificar si el mutex está bloqueado o no?

EDITAR:

Un componente clave de mi problema es que mis hilos (por diseño) se bloquean a sí mismos DESPUÉS de pasar el control a otro hilo. Entonces, cuando el subproceso A pasa el control al subproceso B, el subproceso A está bloqueado, el subproceso B hace algunas cosas y luego, cuando se completa el subproceso B, se desbloquea el subproceso A.

El problema con esto es que si el subproceso B intenta desbloquear el subproceso A y el subproceso A aún no se ha bloqueado, la llamada para desbloquear se pierde y el subproceso A permanece bloqueado, lo que provoca un bloqueo inactivo.

ACTUALIZAR:

Rehice mi programa tomando la sugerencia de caf pero todavía me encuentro con problemas. Moldeé mi programa en la estructura café, siempre que pude, pero ni siquiera puedo decir qué está causando el bloqueo ahora ... He creado una nueva pregunta.aquí buscando ayuda con mi código.

A continuación se muestra una versión ejecutable de la sugerencia de caf. Hice un pequeño reordenamiento en la función para el subproceso a, sin el cual tanto el subproceso a como el subproceso b se habrían bloqueado en su creación, esperando una condición que nunca podría cambiar.

#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);
    }
}