cfd436c287
* Introduce AspiringActor, EstablishedActor
This pair of objects represents the two-phase (parent-thread /
child-thread) construction that's needed to support constructing
Thread<Object> without blocking until the child thread is up and
running.
An `AspiringActor<O>` is responsible for:
- ownership of the actor's `Mailbox`
- allocating the memory for (but *not* constructing) the target object `O`
Using these two pieces--the mailbox and a stable address for `O`--an
`AspiringActor<O>` can accept messages for the target object, or provide
`ActorRef<O>`s that do so, before the object has actually been
constructed by the corresponding `EstablishedActor<O>`. (Such messages
are queued in the mailbox until after the object is constructed.)
This allows for an `AspiringActor<O>` to be created and safely used by a
thread other than the one on which the target object will (eventually)
live.
An `EstablishedActor<O>` is responsible for managing the lifetime of the
target object `O` and the open/closed state of the parent's `mailbox`.
The `O` object's lifetime is contained by that of its owning
`EstablishedActor<O>`: the `EstablishedActor` constructor executes the
`O` constructor via "placement new", constructing it at the address
provided by the parent `AspiringActor`, and the `~EstablishedActor`
destructor similarly executes the `~O` destructor (after closing the
mailbox). `EstablishedActor` should therefore live entirely on the
thread intended to own `O`.
* Remove Actor#{invoke,ask}
51 lines
1.2 KiB
C++
51 lines
1.2 KiB
C++
#pragma once
|
|
|
|
#include <mbgl/util/optional.hpp>
|
|
|
|
#include <memory>
|
|
#include <mutex>
|
|
#include <queue>
|
|
|
|
namespace mbgl {
|
|
|
|
class Scheduler;
|
|
class Message;
|
|
|
|
class Mailbox : public std::enable_shared_from_this<Mailbox> {
|
|
public:
|
|
|
|
// Create a "holding" mailbox, messages to which will remain queued,
|
|
// unconsumed, until the mailbox is associated with a Scheduler using
|
|
// start(). This allows a Mailbox object to be created on one thread and
|
|
// later transferred to a different target thread that may not yet exist.
|
|
Mailbox();
|
|
|
|
Mailbox(Scheduler&);
|
|
|
|
// Attach the given scheduler to this mailbox and begin processing messages
|
|
// sent to it. The mailbox must be a "holding" mailbox, as created by the
|
|
// default constructor Mailbox().
|
|
void open(Scheduler& scheduler_);
|
|
void close();
|
|
|
|
bool isOpen() const;
|
|
|
|
void push(std::unique_ptr<Message>);
|
|
void receive();
|
|
|
|
static void maybeReceive(std::weak_ptr<Mailbox>);
|
|
|
|
private:
|
|
optional<Scheduler*> scheduler;
|
|
|
|
std::recursive_mutex receivingMutex;
|
|
std::mutex pushingMutex;
|
|
|
|
bool closed { false };
|
|
|
|
std::mutex queueMutex;
|
|
std::queue<std::unique_ptr<Message>> queue;
|
|
};
|
|
|
|
} // namespace mbgl
|