I think that instead of using Message objects (for pre C++0x developers) it could be benificial to follow the idiom of generic function callbacks ( your Gotw: 83 et.al ).

This way you can easily make the Active object and Backgrounder without message objects focus on the core with cleaner code as a result.

Inspired by your Effective Concurrency Europe 2009 seminar I ended up with something like this :)

I.e. : (cut-down & pseudo-ish version)
Class Active {
private:
….
void run() {
while(!done){
smart_ptr msg= mq.pop();
msg(); // executes msg
}
}

public:
….
~Active() {
send(bind(this, &Active::DoDone));
thd->join();
}
….
};

class Background {
…
public:
void Save(smart_ptr data) {
active->send(bind(this, &Background::DoSave, data);
}
…
};

Standard pre C++0x but still with the clean look thanks to some template touch :)

Cheers

In my case I wanted to pass a Medium-sized data to an active object. By medium-sized I mean a piece of data big enough that you can afford to copy it one time for the purpose of thread isolation, but NOT many times. (for example a buffer of char[4096])

It worked very easily with OO style message.
struct MMediumSized
{
MediumSizedData data;
MMediumSized(const MediumSizedData& data):data(data){}
void Execute(){…}
}

void foo(const MediumSizedData& data)
{
a.Send(std::unique_ptr(new MMediumSized(data)));
}

The Send() function forced me to do the right thing, thanks to taking an unique_ptr as parameter. The MediumSizedData is copied *once* into the message (in the constructor of MMediumSized) and then the unique_ptr to the message is moved into the message queue, then moved out, get executed and then get automatically destroyed.

I hit way more problems when moving to lambda and std::function. My first impulse was to do :

void foo(const MediumSizedData& data)
{
a.Send( [&data](){ …} );
}
I didn’t pay enough attention that the data was captured by reference, so there is no copy at all which cause data race in the program.
Then I changed to :

void foo(const MediumSizedData& data)
{
a.Send( [data]() {…} );
}

The program was correct, but way slower than the OO version. I put some traces into MediumSizedData copy constructor and realized that every time I called foo() and the message was executed, MediumSizedData get in fact copied 5 times !! It seems that’s because std::function really love to make copy. I cannot figure out what happen exactly in the internals of std::function but is seems that my lambda get copied a LOT inside.

So I finally realize that you have to use a shared_ptr to get the right semantics :
void foo(const MediumSizedData& data)
{
std::shared_ptr data_copy(new MediumSizedData(data));
a.Send( [data_copy]() {…} );
}
I would prefer an unique_ptr but unfortunately it seems that std::function make always a copy of its internals and never a move.

TL:DR :
It’s very clear in the OO style that you dynamically allocate a message and then only manipulate and pass a *pointer* around whereas the std::function way looks more mysterious. What really happen when I construct a std::function from a lambda ? What really happen when I a push a std::function into the message queue ?

Excellent read.
Are you planning to compile all the column in the book?

Thanks