Eu preciso ver se um mutex está bloqueado ou desbloqueado em uma instrução if, então eu verifico assim ...

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

mas quando eu verifico, o gcc me dá o seguinte erro:

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

Então, como posso verificar se o mutex está bloqueado ou não?

EDITAR:

Um componente essencial para o meu problema é que meus threads (por design) se bloqueiam logo após passar o controle para outro thread. Portanto, quando o segmento A passa o controle para o segmento B, o segmento A está bloqueado, o segmento B faz algumas coisas; quando o segmento B é concluído, ele desbloqueia o segmento A.

O problema é que, se o encadeamento B tentar desbloquear o encadeamento A e o encadeamento A ainda não tiver concluído o bloqueio, a chamada para desbloquear será perdida e o encadeamento A permanecerá bloqueado, causando um bloqueio morto.

ATUALIZAR:

Eu refiz meu programa seguindo a sugestão do caf, mas ainda estou com problemas. Eu moldei meu programa na estrutura caf, desde o melhor que posso, mas não posso nem dizer o que está causando o impasse agora ... Criei uma nova perguntaaqui procurando ajuda com meu código.

Abaixo está uma versão executável da sugestão do caf. Fiz uma pequena reordenação na função do encadeamento a, sem a qual os encadeamentos a e b teriam sido bloqueados durante a criação, aguardando uma condição que nunca poderia mudar.

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