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}
47 lines
1.6 KiB
C++
47 lines
1.6 KiB
C++
#pragma once
|
|
|
|
#include <memory>
|
|
|
|
namespace mbgl {
|
|
|
|
class Mailbox;
|
|
|
|
/*
|
|
A `Scheduler` is responsible for coordinating the processing of messages by
|
|
one or more actors via their mailboxes. It's an abstract interface. Currently,
|
|
the following concrete implementations exist:
|
|
|
|
* `ThreadPool` can coordinate an unlimited number of actors over any number of
|
|
threads via a pool, preserving the following behaviors:
|
|
|
|
- Messages from each individual mailbox are processed in order
|
|
- Only a single message from a mailbox is processed at a time; there is no
|
|
concurrency within a mailbox
|
|
|
|
Subject to these constraints, processing can happen on whatever thread in the
|
|
pool is available.
|
|
|
|
* `Scheduler::GetCurrent()` is typically used to create a mailbox and `ActorRef`
|
|
for an object that lives on the main thread and is not itself wrapped an
|
|
`Actor`. The underlying implementation of this Scheduler should usually be
|
|
a `RunLoop`
|
|
auto mailbox = std::make_shared<Mailbox>(*Scheduler::Get());
|
|
Actor<Worker> worker(threadPool, ActorRef<Foo>(*this, mailbox));
|
|
*/
|
|
class Scheduler {
|
|
public:
|
|
virtual ~Scheduler() = default;
|
|
|
|
// Used by a Mailbox when it has a message in its queue to request that it
|
|
// be scheduled. Specifically, the scheduler is expected to asynchronously
|
|
// call `receive() on the given mailbox, provided it still exists at that
|
|
// time.
|
|
virtual void schedule(std::weak_ptr<Mailbox>) = 0;
|
|
|
|
// Set/Get the current Scheduler for this thread
|
|
static Scheduler* GetCurrent();
|
|
static void SetCurrent(Scheduler*);
|
|
};
|
|
|
|
} // namespace mbgl
|