title: Check to see if a pthread mutex is locked or unlocked (After a thread has locked itself)
body: <p>I need to see if a mutex is locked or unlocked in an if statement so I check it like this...</p>
  
  <pre><code>if(mutex[id] != 2){
      /* do stuff */
  }
  </code></pre>
  
  <p>but when I check it gcc gives me the following error:</p>
  
  <p><code>error: invalid operands to binary != (have 'ptherad_mutex_t' and 'int')</code></p>
  
  <p>So how can I check to see if the mutex is locked or not?</p>
  
  <p><strong>EDIT:</strong></p>
  
  <p>A key component to my problem is that my threads (by design) lock themselves right AFTER passing control to another thread.  So when thread A passes control to thread B thread A is locked, thread B does some stuff, then when thread B is done it will unlock thread A.  </p>
  
  <p>The problem with this is that if thread B attempts to unlock thread A and thread A has not yet completed locking itself then the call to unlock is lost and thread A remains locked which causes a dead lock.</p>
  
  <p><strong>UPDATE:</strong></p>
  
  <p>I remade my program taking caf's suggestion but I am still running into problems.  I have molded my program into the structure caf provided the best I can but I cannot even tell what is causing the dead lock now...  I have created a new question <a href="https://stackoverflow.com/questions/4381782/pthread-program-deadlocks-using-condition-variables">here</a> seeking help with my code.</p>
  
  <p>Below is a runnable version of caf's suggestion.  I made a small reordering in the function for thread a, without which both thread a and thread b would have been locked upon their creation, waiting for a condition that could never change.</p>
  
  <pre><code>#include &lt;pthread.h&gt;
  
  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(&amp;thread_a, NULL, a, (void *)0);
      pthread_create(&amp;thread_b, NULL, b, (void *)0);
  
      pthread_join(thread_a, (void **)&amp;status);
      pthread_join(thread_b, (void **)&amp;status);
  
  }
  
  /* thread A */
  void *a(void *i){
      while (1) {
          printf("thread A is running\n");
          sleep(1);
  
          /* unlock thread B */
          pthread_mutex_lock(&amp;lock_b);
              run_b = 1;
              pthread_cond_signal(&amp;cond_b);
          pthread_mutex_unlock(&amp;lock_b);
  
          /* wait for thread A to be runnable */
          pthread_mutex_lock(&amp;lock_a);
              while (!run_a)
                  pthread_cond_wait(&amp;cond_a, &amp;lock_a);
              run_a = 0;
          pthread_mutex_unlock(&amp;lock_a);      
      }
  }
  
  /* thread B */
  void *b(void *i){
      while (1) {
          /* wait for thread B to be runnable */
          pthread_mutex_lock(&amp;lock_b);
              while (!run_b)
                  pthread_cond_wait(&amp;cond_b, &amp;lock_b);
              run_b = 0;
          pthread_mutex_unlock(&amp;lock_b);
  
          printf("thread B is running\n");
          sleep(1);
  
          /* unlock thread A */
          pthread_mutex_lock(&amp;lock_a);
              run_a = 1;
              pthread_cond_signal(&amp;cond_a);
          pthread_mutex_unlock(&amp;lock_a);
      }
  }
  </code></pre>