Question

My program is seemingly having a deadlock problem.

Basically I have a class that looks like this:

class Foo {
public:
  Foo();

  void bar();

private:
  void monitor();

  bool condition_;
  pthread_t monitor_;
  pthread_mutex_t mutex_;
  pthread_cond_t cv_;
};

In Foo‘s constructor, I invoke monitor() in a separate thread (namely monitor_). This monitor() function does the following:

pthread_mutex_lock(&mutex_);
while (true) {
  while (!condition_) {
    pthread_cond_wait(&cv_, &mutex_);
  }
  // do something
  // and then setting condition_ to false
  condition_ = false;
}
pthread_mutex_unlock(&mutex_);

The bar() function is the only public interface (excluding ctor and dtor) of Foo. It also needs to acquire the mutex in its execution. My symptom is that bar() can never acquire mutex_. It looks like pthread_cond_wait() does not release the mutex as it is supposed to do. And if I disable the monitor thread (thus no racing condition), then bar() can run to its completion without any problem.

Of course, the above code is a stripped-down version of my real code. Actually I think there is no logic error in this code and I’m using pthread correctly. I’m suspecting if there are any other causes for this deadlock situation. Can anyone give a clue on this? Thanks!

Answer 1

I would look at your constructor and the bar() function, and possibly if you’ve accidentally made a copy of the object in question. I’ve copied the classes you provided, and my assumptions on how the rest of it operates below. The program below wakes up every second, and signals the thread.

#include <pthread.h>
#include <iostream>

class Foo {
public:
  Foo() {
    condition_ = false;
    pthread_mutex_init(&mutex_, NULL);
    pthread_cond_init(&cv_, NULL);
    pthread_create(&monitor_, NULL,
           startFunc, this);
  }

  void bar() {
    pthread_mutex_lock(&mutex_);
    std::cout << "BAR" << std::endl;
    condition_ = true;
    pthread_cond_signal(&cv_);
    pthread_mutex_unlock(&mutex_);
  }

private:
  Foo(const Foo&) {};
  Foo& operator=(const Foo&) { return *this; };

  static void* startFunc(void* r) {
    Foo* f = static_cast<Foo*>(r);
    f->monitor();
    return NULL;
  }

  void monitor() {
    pthread_mutex_lock(&mutex_);
    while (true) {
      while (!condition_) {
    pthread_cond_wait(&cv_, &mutex_);
      }
      // do something
      // and then setting condition_ to false
      std::cout << "FOO" << std::endl;
      condition_ = false;
    }
    pthread_mutex_unlock(&mutex_);

  }

  bool condition_;
  pthread_t monitor_;
  pthread_mutex_t mutex_;
  pthread_cond_t cv_;
};


int main() {
  struct timespec tm = {1,0};
  Foo f;

  while(true) {
    f.bar();
    nanosleep(&tm, NULL);
  }

}