Implementation of the Active Object pattern wrapping a standard C++ thread.

• Whole implementation contained in a single header file!
• Inherit from a template and you are done. See the tiny example bellow.

• Exchange messages of any type (does not requires them to derive from a common base class)
• Messages are asynchronously delivered in the same order they were sent
• Allows to invoke callbacks on clients of unknown type (useful for libraries)
• Callbacks on the active object auto-store themselves with no boilerplate code
• Timers ability with client-driven handlers (no need for handler↔object resolving maps)

• Internal lock-free MPSC messages queue
• Extensive internal use of move semantics supporting delivery of non-copiable objects
• Several million msg/sec between each two threads (both Linux and Windows) in ordinary hardware

• The wrapped thread lifecycle overlaps and is driven by the object existence
• The object is kept alive by smart pointers (whoever has a reference can safely send messages)
• No internal strong references (only the final users determine the destruction/end)
• Nonetheless, callbacks onto already deleted active objects do not crash the application

• Mininum gcc version supported is 8.
• Works with clang 5 and Visual Studio 2017.
• Clean, standard C++17 (no conditional code, same implementation for all platforms)

#include <samiralavi/activecpp.h> #include <string> #include <iostream> #include <sstream> using namespace samiralavi; struct Message { std::string description; }; struct OtherMessage { double beautifulness; }; class Consumer : public ActorThread<Consumer> { friend ActorThread<Consumer>; void onMessage(Message& p) { std::cout << "thread " << std::this_thread::get_id() << " receiving " << p.description << std::endl; } void onMessage(OtherMessage& p) { std::cout << "thread " << std::this_thread::get_id() << " receiving " << p.beautifulness << std::endl; } }; class Producer : public ActorThread<Producer> { friend ActorThread<Producer>; std::shared_ptr<Consumer> consumer; void onMessage(std::shared_ptr<Consumer>& c) { consumer = c; timerStart(true, std::chrono::milliseconds(250), TimerCycle::Periodic); timerStart(3.14, std::chrono::milliseconds(333), TimerCycle::Periodic); } void onTimer(const bool&) { std::ostringstream report; report << "test from thread " << std::this_thread::get_id(); consumer->send(Message { report.str() }); } void onTimer(const double& value) { consumer->send(OtherMessage { value }); } }; class Application : public ActorThread<Application> { friend ActorThread<Application>; void onStart() { auto consumer = Consumer::create(); // spawn new threads auto producer = Producer::create(); producer->send(consumer); std::this_thread::sleep_for(std::chrono::seconds(3)); stop(); } }; int main() { return Application::run(); // re-use existing thread }

Despite received by reference, a copy of the original object is delivered to the destination thread. Alternatively, the carried object can be moved, which is the way to transfer non-copiable objects like a unique_ptr. Copying is highly efficient with pointers, but note that several threads must not concurrently access a unsafe pointed object.

See the examples folder for more elaborated examples, including a library and its client using the callbacks mechanism.