pthread.cpp

/**********************************************************************
 * This is an example of using C++ classes within a C-style callback
 * framework, plus a rudimentary example of using POSIX threads. See <
 * http://www.fsmlabs.com/developers/docs/html/susv2/xsh/pthread.h.html
 * > for more information on POSIX threads in general. POSIX threads
 * are available on most Unix platforms, plus Windows via the Cygwin
 * package <http://www.cygwin.com/>.
 * 
 * The Thread class defined here is hardly complete. It doesn't support
 * all thread operations that POSIX threads support; it doesn't even
 * support locking. For that reason, you should not use this code in
 * any sort of production environment. This is for educational purposes
 * only.
 * 
 * If you're actually planning on working with threads, it would be
 * best to use a serious, portable, and supported threading library,
 * such as the following:
 * 
 *   * ACE
 *     <http://www.cs.wustl.edu/~schmidt/ACE.html>
 *   * Boost threads
 *     <http://www.boost.org/libs/thread/doc/>
 *   * GNU Common C++
 *     <http://www.gnu.org/software/commonc++/>
 * 
 * Caveat haxor.
 * 
 * P.S. Don't forget to link in the POSIX threads library. The
 * mechanism to do this varies from system to system. If you're using
 * g++, it may be as simple as this:
 * 
 * g++ Thread.cpp main.cpp -pthread
 * 
 * (On Cygwin, the -pthread flag elicits a warning, but still works.)
 * 
 * There is also a makefile provided which will build the software for
 * you. If you have Make installed on your system, just run it:
 * 
 * make
 * 
 * If this doesn't work for you, consult your documentation.
 * 
 **********************************************************************/

/**********************************************************************
 * Thread.hpp
 **********************************************************************/
#ifndef THREAD_HPP_eerniocgherioghv45ogin4h5g4
#define THREAD_HPP_eerniocgherioghv45ogin4h5g4

#include <pthread.h>

//! Derive from this class to prevent copying or assignment in cases
//! where such would be undesirable or ambiguous.
//! See also <http://www.boost.org/libs/utility/utility.htm>.
class Noncopyable {
protected:
  Noncopyable () { }
  ~Noncopyable () { }

private:
  Noncopyable (const Noncopyable &);            // unimplemented
  Noncopyable &operator= (const Noncopyable &); // unimplemented
};

//! Base class for an object which runs in its own thread of execution.
class Thread : private Noncopyable {
public:
  //! Start execution of the thread.
  //! @return 0      on success, or
  //!         EAGAIN if thread could not be created due to system
  //!                limitations or if the thread is already running.
  int start ();

  //! Determine whether this thread object is currently running.
  bool running () const;

  //! Waits for thread to finish.
  //! @return 0       on success,
  //!         EINVAL  if the thread could not be joined,
  //!         ESRCH   if the thread does not exist, or
  //!         EDEADLK if joining this thread would cause deadlock.
  int join ();

protected:
  Thread ();

  //! Waits for the thread to finish before destroying the Thread object.
  virtual ~Thread ();

private:
  //! The ID of this thread object.
  //! Made volatile as per the recommendation of Alexei Alexandrescu
  //! in his article <http://www.cuj.com/experts/1902/alexandr.htm>.
  volatile pthread_t myId;

  //! Callback method supplied to pthread_create(). Return type void *
  //! is required by POSIX, but return value is ignored by this code.
  //! @param   vthread   pointer to a Thread object
  static void *do_start (void *vthread);

  //! Toggle whether this thread is running.
  void running (bool status);

  //! Called before run() in the new thread.
  virtual void init ();

  //! Called in the new thread.
  virtual void run ();

  //! Called after run() in the new thread.
  virtual void fini ();
};

#endif

/**********************************************************************
 * main.cpp
 **********************************************************************/
#include <iostream>
#include <assert.h>
#include <unistd.h>

class MyThread : public Thread {
private:
  virtual void init ();
  virtual void run ();
  virtual void fini ();
};

int main (int argc, char *argv[]) {
  MyThread mythr;

  std::cout << "<main> starting" << std::endl;

  assert(!mythr.running());
  assert(mythr.start() == 0);
  assert(mythr.running());
  assert(mythr.join() == 0);
  assert(!mythr.running());

  std::cout << "<main> done" << std::endl;

  return 0;
}

void MyThread::init () {
  std::cout << "<thread> MyThread::init()" << std::endl;
}

void MyThread::run () {
  std::cout << "<thread> begin MyThread::run()" << std::endl;

  for (int i = 0; i < 10; ++i) {
    std::cout << "<thread> " << i << std::endl;
    sleep(1);
  }

  std::cout << "<thread> end MyThread::run()" << std::endl;
}

void MyThread::fini () {
  std::cout << "<thread> MyThread::fini()" << std::endl;
}

/**********************************************************************
 * Thread.cpp
 **********************************************************************/
#include <errno.h>
#include <unistd.h>

namespace {
  const pthread_t notRunning = 0;
}

Thread::Thread ()
  : myId(notRunning) {
}

int Thread::start () {
  return (!running()
	  ? pthread_create(const_cast<pthread_t *>(&myId), 0,
			   &do_start, this)
	  : EAGAIN);
}

bool Thread::running () const {
  return (myId != notRunning);
}

void Thread::running (bool status) {
  // Note: pthread_create() also sets myId; however, Thread::init() might
  // be called before this occurs. Naturally, Thread::running() ought to
  // return true while the thread is running; hence, set myId here to make
  // sure of this.
  myId = status ? pthread_self() : notRunning;
}

int Thread::join () {
  return running() ? pthread_join(myId, 0) : ESRCH;
}

Thread::~Thread () {
  join();
}

void *Thread::do_start (void *vthread) {
  Thread *thread = static_cast<Thread *>(vthread);

  thread->running(true);
  thread->init();
  thread->run();
  thread->fini();
  thread->running(false);

  return 0;
}

void Thread::init () { }
void Thread::run () { }
void Thread::fini () { }