Using aout
– A Concurrency-safe Wrapper for cout
¶
When using cout
from multiple actors, output often appears
interleaved. Moreover, using cout
from multiple actors – and thus
from multiple threads – in parallel should be avoided regardless, since the
standard does not guarantee a thread-safe implementation.
By replacing std::cout
with caf::aout
, actors can achieve a
concurrency-safe text output. The header caf/all.hpp
also defines overloads
for std::endl
and std::flush
for aout
, but does not support the full
range of ostream operations (yet). Each write operation to aout
sends a
message to a “hidden” actor. This actor only prints lines, unless output is
forced using flush
. The example below illustrates printing of lines of text
from multiple actors (in random order).
#include "caf/actor_ostream.hpp"
#include "caf/actor_system.hpp"
#include "caf/caf_main.hpp"
#include "caf/event_based_actor.hpp"
#include <chrono>
#include <cstdlib>
#include <iostream>
#include <random>
using namespace caf;
behavior printer(event_based_actor* self, int32_t num, int32_t delay) {
aout(self).println("Hi there! This is actor nr. {}!", num);
auto timeout = std::chrono::milliseconds{delay};
self->delayed_send(self, timeout, timeout_atom_v);
return {
[=](timeout_atom) {
aout(self).println("Actor nr. {} says goodbye after waiting for {}ms!",
num, delay);
},
};
}
void caf_main(actor_system& sys) {
std::random_device rd;
std::minstd_rand re{rd()};
std::uniform_int_distribution<int32_t> dis{1, 99};
for (int32_t i = 1; i <= 50; ++i)
sys.spawn(printer, i, dis(re));
}
CAF_MAIN()