Re: What's the connection between objects and threads?

From:

"Chris Thomasson" <cristom@comcast.net>

Newsgroups:

comp.lang.c++

Date:

Sat, 17 May 2008 20:35:48 -0700

Message-ID:

<c6udnaWa5paRObLVnZ2dnUVZ_hGdnZ2d@comcast.com>

"darren" <minofifa@gmail.com> wrote in message
news:3e1c2116-118e-4a9a-bed8-44e446e31bc7@d19g2000prm.googlegroups.com...

Thanks for the responses everybody.

I have actually heard of Boost. I saw it in another post on this user
group about threads. My dilemma is that for this project, we were
specifically told that we must use the pthread library and our
deliverable must only be source code and a Makefile.

Doest Boost use pthread library calls in its implementation, or are
they up to something else? Maybe I'll email my prof and ask if using
Boost is permitted.

As for my current idea:

I planned to write a class called myThreads which would wrap up calls
to the pthread library, like pthread_create. Then anytime i need a
thread I'll instantiate one of these objects. I was thinking that in
one of these 'myThread" constructors, a new thread would be created
and ran. Again, i'm new to thread programming, so i dont know if this
will work or not.

[...]

You don't generally want to create threads in constructors because of a
possible race-condition. Think of starting a thread in an object's
constructor which starts to run and operate on it _before_ its ctor has
finished... Anyway:

http://groups.google.com/group/comp.programming.threads/browse_frm/thread/b9b2ce54349af0f
(please read all!)

Here is some very simple source-code that might help you:
____________________________________________________________________

/* VERY Simple Thread Library Code
______________________________________________________________*/
#include <pthread.h>

class thread_base;
extern "C" void* thread_base_entry(void*);
static void thread_create(thread_base* const);
static void thread_join(thread_base* const);

class thread_base {
  pthread_t m_id;
  friend void* thread_base_entry(void*);
  friend void thread_create(thread_base* const);
  friend void thread_join(thread_base* const);
  virtual void on_thread_entry() = 0;
public:
  virtual ~thread_base() throw() = 0;
};

thread_base::~thread_base() throw() {}

void* thread_base_entry(void* state) {
  reinterpret_cast<thread_base*>(state)->on_thread_entry();
  return 0;
}

void thread_create(thread_base* const _this) {
  int const status = pthread_create(&_this->m_id, NULL,
                        thread_base_entry, _this);
  if (status) {
    throw int(status);
  }
}

void thread_join(thread_base* const _this) {
  int const status = pthread_join(_this->m_id, NULL);
  if (status) {
    throw int(status);
  }
}

/* Very Simple Application Code
______________________________________________________________*/
#include <cstdio>

class my_thread : public thread_base {
public:
  my_thread() {
    std::printf("(%p)-my_thread::my_thread()\n",
      reinterpret_cast<void*>(this));
  }

  ~my_thread() throw() {
    std::printf("(%p)-my_thread::~my_thread() throw()\n",
      reinterpret_cast<void*>(this));
  }

private:
  void on_thread_entry() {
    std::printf("void (%p)-my_thread::on_thread_entry()\n",
      reinterpret_cast<void*>(this));
  }
};

#define RUN_DEPTH() 10
#define THREAD_DEPTH() 32
int main() {
  int runs = 0;
  for (; runs < RUN_DEPTH(); ++runs) {
    int i = 0;
    my_thread threads[THREAD_DEPTH()];

    try {
      for (; i < THREAD_DEPTH(); ++i) {
        thread_create(&threads[i]);
      }
    } catch (int const& e) {
      std::printf("thread_create throws status %d!\n", e);
    }

    for (--i; i > -1; --i) {
      try {
        thread_join(&threads[i]);
      } catch (int const& e) {
        std::printf("thread_join throws status %d!\n", e);
      }
    }
  }

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  std::puts("\n\n____________________________________________\n\
Press <ENTER> to exit...");
  std::getchar();
  return 0;
}

____________________________________________________________________

Any questions?