Thread: Multithreading and Class Objects

Are you using a compiler that does not support C++11? If not, then you should be using std::thread instead of pthreads.

The mutex will ensure that only one thread can operate on the object at once.

But it won't do anything to control which order the 4 threads will execute in.

Originally Posted by nickman

So it mean that if one thread lock mutex say Thread1, then it will execute:

and once the mutex is unlock then Thread2 will take control.

No, it does not mean that. It is entirely possible that Thread1 will execute fully and terminating before any of the other threads can do any work. Threads by themselves aren't fair. What you can guarantee is that only ONE thread will execute those statements at a time.

A typical scenario would be that all 4 threads execute pthread_mutex_lock(&count_mutex); at almost the same time.
One of them will succeed and go onto cap->validateStudent(temp); and the others will block.

When the running thread executes pthread_mutex_unlock(&count_mutex); the platform picks some other thread waiting on the mutex and allows it to continue. Which thread executes next is random, but in the long run, each thread will get a fair share of CPU time.


> So what should I use? Shemaphores?
I don't know. It might be better to describe your problem rather than us try and reverse engineer the requirement from some broken implementation approach.

> I was thinking that mutex lock will ensure that untill it is unlock no thread will take control.
It will, if startCapture() started with pthread_mutex_lock(&count_mutex); before calling all those pthread_creates.

> As currently I am seeing that with above code, both thread are executing the function.
What did you expect?

If you wanted capture1 to run to completion, then capture2 to run to completion, then why are you even messing about with threads?

If you want this behaviour with threads, then you need a different approach.

Works for me

Code:

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

using namespace std;

pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;

class Student
{
public:
  Student() : last(0) { }
  
  static void *capture1(void *arg) {
    Student *cap = static_cast<Student*>(arg);
    for ( int i = 0 ; i < 10000 ; i++ ) {
      pthread_mutex_lock(&count_mutex);
      cap->dowork(i);
      pthread_mutex_unlock(&count_mutex);
    }
    return NULL;
  }
  static void *capture2(void *arg) {
    Student *cap = static_cast<Student*>(arg);
    for ( int i = 0 ; i < 10000 ; i++ ) {
      pthread_mutex_lock(&count_mutex);
      cap->dowork(i);
      pthread_mutex_unlock(&count_mutex);
    }
    return NULL;
  }
  static void *capture3(void *arg) {
    Student *cap = static_cast<Student*>(arg);
    for ( int i = 0 ; i < 10000 ; i++ ) {
      pthread_mutex_lock(&count_mutex);
      cap->dowork(i);
      pthread_mutex_unlock(&count_mutex);
    }
    return NULL;
  }
  static void *capture4(void *arg) {
    Student *cap = static_cast<Student*>(arg);
    for ( int i = 0 ; i < 10000 ; i++ ) {
      pthread_mutex_lock(&count_mutex);
      cap->dowork(i);
      pthread_mutex_unlock(&count_mutex);
    }
    return NULL;
  }
  void dowork(int i) {
    if ( last != pthread_self() ) {
      cout << "Worker " << this 
           << " on thread " << pthread_self() 
           << " resumed at " << i << endl;
      last = pthread_self();
    }
  }
  void start() {
    int rc;
    pthread_mutex_lock(&count_mutex);
    pthread_attr_t attr;
    cout << "Creating threads....";
    pthread_attr_init(&attr);
    rc =  pthread_create(&threads[0], &attr, capture1, (void *)this);
    rc =  pthread_create(&threads[1], &attr, capture2, (void *)this);
    rc =  pthread_create(&threads[2], &attr, capture3, (void *)this);
    rc =  pthread_create(&threads[3], &attr, capture4, (void *)this);
    pthread_attr_destroy(&attr);
    cout << "done" << endl;
    pthread_mutex_unlock(&count_mutex);
  }
  void end() {
    void *res;
    pthread_join(threads[0],&res);
    pthread_join(threads[1],&res);
    pthread_join(threads[2],&res);
    pthread_join(threads[3],&res);
  }
private:
  pthread_t threads[4];
  pthread_t last;
};

int main ( ) {
  Student s;
  cout << "Main Start" << endl;
  s.start();  // sow
  s.end();    // reap
  cout << "Main End" << endl;
}


$ g++ foo.cpp -pthread
$ ./a.out 
Main Start
Creating threads....done
Worker 0x7fff037a2980 on thread 140706368927488 resumed at 0
Worker 0x7fff037a2980 on thread 140706377320192 resumed at 0
Worker 0x7fff037a2980 on thread 140706352142080 resumed at 0
Worker 0x7fff037a2980 on thread 140706368927488 resumed at 755
Worker 0x7fff037a2980 on thread 140706360534784 resumed at 0
Worker 0x7fff037a2980 on thread 140706368927488 resumed at 927
Worker 0x7fff037a2980 on thread 140706360534784 resumed at 142
Worker 0x7fff037a2980 on thread 140706352142080 resumed at 185
Worker 0x7fff037a2980 on thread 140706360534784 resumed at 143
Worker 0x7fff037a2980 on thread 140706352142080 resumed at 356
Worker 0x7fff037a2980 on thread 140706377320192 resumed at 210

Sure, if they're independent objects, then there is little need for a mutex is there.

But all your examples have been 4 instances of 'this' as the data parameter to pthread_create.