Проверить, заблокирован или разблокирован мьютекс pthread (после того, как поток заблокировал себя)

Мне нужно увидеть, заблокирован или разблокирован мьютекс в операторе if, поэтому я проверяю это так ...

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

но когда Я проверяю, что gcc выдает следующую ошибку:

error: недопустимые операнды для двоичного файла! = (Имеют 'ptherad_mutex_t' и 'int')

Итак, как я могу проверить, заблокирован ли мьютекс или нет?

РЕДАКТИРОВАТЬ:

Ключевым компонентом моей проблемы является то, что мои потоки (по замыслу) блокируются сразу ПОСЛЕ передачи управления другому потоку. Поэтому, когда поток A передает управление потоку B, поток A заблокирован, поток B выполняет некоторые действия, а затем, когда поток B завершен, он разблокирует поток A.

Проблема заключается в том, что если поток B пытается разблокировать поток A, а поток A еще не завершил блокировку, вызов разблокировки теряется, а поток A остается заблокированным, что вызывает мертвую блокировку.

ОБНОВЛЕНИЕ:

Я переделал свою программу с учетом предложения caf, но у меня все еще возникают проблемы. Я встроил свою программу в структуру caf, насколько это возможно, но я даже не могу сказать, что вызывает тупик сейчас ... Я создал новый вопрос здесь , ища помощи с моим кодом.

Ниже представлена ​​исполняемая версия предложения caf. Я сделал небольшое переупорядочение функции для потока a, без которого поток a и поток b были бы заблокированы при их создании, ожидая условия, которое никогда не могло измениться.

#include 

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