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

From:

"Chris Thomasson" <cristom@comcast.net>

Newsgroups:

comp.lang.c++

Date:

Tue, 3 Jun 2008 06:37:08 -0700

Message-ID:

<5tudnXL8R8ZT1djVnZ2dnUVZ_g6dnZ2d@comcast.com>

"Szabolcs Ferenczi" <szabolcs.ferenczi@gmail.com> wrote in message
news:703e47a7-20f0-4bc1-bd8d-1d1a3e045908@m36g2000hse.googlegroups.com...
On May 22, 1:55 am, "Chris Thomasson" <cris...@comcast.net> wrote:

"darren" <minof...@gmail.com> wrote in message

news:7083eb1a-4dbd-4b94-866b-fddab7300186@c19g2000prf.googlegroups.com...

Hi

I have to write a multi-threaded program. I decided to take an OO
approach to it. I had the idea to wrap up all of the thread functions
in a mix-in class called Threadable. Then when an object should run
in its own thread, it should implement this mix-in class. Does this
sound like plausible design decision?

I'm surprised that C++ doesn't have such functionality, say in its
STL. This absence of a thread/object relationship in C++ leads me to
believe that my idea isn't a very good one.

I would appreciate your insights. thanks

Here is a helper object you can use to run objects that provide a specific
interface (e.g., foo::start/join):
_________________________________________________________________

[...]

_________________________________________________________________

To create and start an object in one step you do:

[...]

However, other than perhaps some syntactic-sugar, I don't think that this
gives any advantages over Boost's method of representing and creating
threads...

Any thoughts?

I do think it has advantages over Boost's method. One such advantage
is the RAII nature of it.

Okay. Good point.

Furthermore, I think it should be taken in into the C++0x standard on
the similar grounds as they provide higher level condition variable
wait API as well:

[...]

However, one further improvement could be nice, and in that case it
would be quite a general solution, if one could just denote which
method of the object one wants to start as a process.

Check this out Szabolcs:
_____________________________________________________________________
#include <cstdio>

/* Active Object Helper
______________________________________________________________*/
template<
typename T,
void (T::*T_fp_start) () = &T::start,
void (T::*T_fp_join) () = &T::join

struct active {

  T object;

  struct guard {
    T& object;

    guard(T& _object) : object(_object) {
      (object.*T_fp_start)();
    }

    ~guard() {
      (object.*T_fp_join)();
    }
  };

  active() {
    (object.*T_fp_start)();
  }

  ~active() {
    (object.*T_fp_join)();
  }
};

/* Sample usage
______________________________________________________________*/
struct foo1 {
  foo1() {
    std::printf("(%p)->foo1::foo1()\n", (void*)this);
  }

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

  void start() {
    std::printf("(%p)->void foo1::start()\n", (void*)this);
  }

  void join() {
    std::printf("(%p)->void foo1::join()\n", (void*)this);
  }
};

struct foo2 {
  foo2() {
    std::printf("(%p)->foo2::foo2()\n", (void*)this);
  }

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

  void run() {
    std::printf("(%p)->void foo2::run()\n", (void*)this);
  }

  void wait() {
    std::printf("(%p)->void foo2::wait()\n", (void*)this);
  }
};

struct foo3 {
  foo3() {
    std::printf("(%p)->foo3::foo3()\n", (void*)this);
  }

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

  void spawn() {
    std::printf("(%p)->void foo3::spawn()\n", (void*)this);
  }

  void join() {
    std::printf("(%p)->void foo3::join()\n", (void*)this);
  }
};

struct foo4 {
  foo4() {
    std::printf("(%p)->foo4::foo4()\n", (void*)this);
  }

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

  void activate() {
    std::printf("(%p)->void foo4::activate()\n", (void*)this);
  }

  void deactivate() {
    std::printf("(%p)->void foo4::deactivate()\n", (void*)this);
  }
};

int main() {
  {
    foo4 _foo4;
    active<foo1> _foo1;
    active<foo2, &foo2::run, &foo2::wait> _foo2;
    active<foo3, &foo3::spawn> _foo3;
    active<foo4, &foo4::activate, &foo4::deactivate>::guard __foo4(_foo4);
  }
  std::puts("\n\npress <ENTER> to exit...");
  std::getchar();
  return 0;
}

_____________________________________________________________________

All objects with an interface of `T::start/join()' can simply use the
following syntax:

{
  active<object> o;
}

Other objects which have a custom function to start as a process could do
something like:

{
  active<object, &object::start_my_process> o;
}

Furthermore, object which have a custom function to start a process, and a
custom function to join with it could do:

{
  active<object, &object::start_my_process, &object::join_my_process> o;
}

Do you have any other suggestions on how to further improve the `active<T>'
helper object?