Struct actix::sync::SyncArbiter
source · [−]pub struct SyncArbiter<A> where
A: Actor<Context = SyncContext<A>>, { /* private fields */ }
Expand description
SyncArbiter
provides the resources for a single Sync Actor to run on a dedicated
thread or threads. This is generally used for CPU bound concurrent workloads. It’s
important to note, that the SyncArbiter
generates a single address for the pool
of hosted Sync Actors. Any message sent to this Address, will be operated on by
a single Sync Actor from the pool.
Sync Actors have a different lifecycle compared to Actors on the System
Arbiter. For more, see SyncContext
.
Examples
use actix::prelude::*;
struct Fibonacci(pub u32);
struct SyncActor;
impl Actor for SyncActor {
// It's important to note that you use "SyncContext" here instead of "Context".
type Context = SyncContext<Self>;
}
impl Handler<Fibonacci> for SyncActor {
type Result = Result<u64, ()>;
fn handle(&mut self, msg: Fibonacci, _: &mut Self::Context) -> Self::Result {
if msg.0 == 0 {
Err(())
} else if msg.0 == 1 {
Ok(1)
} else {
let mut i = 0;
let mut sum = 0;
let mut last = 0;
let mut curr = 1;
while i < msg.0 - 1 {
sum = last + curr;
last = curr;
curr = sum;
i += 1;
}
Ok(sum)
}
}
}
fn main() {
System::new().block_on(async {
// Start the SyncArbiter with 2 threads, and receive the address of the Actor pool.
let addr = SyncArbiter::start(2, || SyncActor);
// send 5 messages
for n in 5..10 {
// As there are 2 threads, there are at least 2 messages always being processed
// concurrently by the SyncActor.
addr.do_send(Fibonacci(n));
}
});
}
Implementations
sourceimpl<A> SyncArbiter<A> where
A: Actor<Context = SyncContext<A>>,
impl<A> SyncArbiter<A> where
A: Actor<Context = SyncContext<A>>,
sourcepub fn start<F>(threads: usize, factory: F) -> Addr<A> where
F: Fn() -> A + Send + Sync + 'static,
pub fn start<F>(threads: usize, factory: F) -> Addr<A> where
F: Fn() -> A + Send + Sync + 'static,
Start a new SyncArbiter
with specified number of worker threads.
Returns a single address of the started actor. A single address is
used to communicate to the actor(s), and messages are handled by
the next available Actor in the SyncArbiter
.
Trait Implementations
sourceimpl<A> Actor for SyncArbiter<A> where
A: Actor<Context = SyncContext<A>>,
impl<A> Actor for SyncArbiter<A> where
A: Actor<Context = SyncContext<A>>,
sourcefn started(&mut self, ctx: &mut Self::Context)
fn started(&mut self, ctx: &mut Self::Context)
Called when an actor gets polled the first time.
sourcefn stopping(&mut self, ctx: &mut Self::Context) -> Running
fn stopping(&mut self, ctx: &mut Self::Context) -> Running
Called after an actor is in Actor::Stopping
state. Read more
sourcefn start(self) -> Addr<Self> where
Self: Actor<Context = Context<Self>>,
fn start(self) -> Addr<Self> where
Self: Actor<Context = Context<Self>>,
Start a new asynchronous actor, returning its address. Read more
sourcefn start_default() -> Addr<Self> where
Self: Actor<Context = Context<Self>> + Default,
fn start_default() -> Addr<Self> where
Self: Actor<Context = Context<Self>> + Default,
Construct and start a new asynchronous actor, returning its address. Read more
sourcefn start_in_arbiter<F>(wrk: &ArbiterHandle, f: F) -> Addr<Self> where
Self: Actor<Context = Context<Self>>,
F: FnOnce(&mut Context<Self>) -> Self + Send + 'static,
fn start_in_arbiter<F>(wrk: &ArbiterHandle, f: F) -> Addr<Self> where
Self: Actor<Context = Context<Self>>,
F: FnOnce(&mut Context<Self>) -> Self + Send + 'static,
Start new actor in arbiter’s thread.
Auto Trait Implementations
impl<A> !RefUnwindSafe for SyncArbiter<A>
impl<A> Send for SyncArbiter<A>
impl<A> Sync for SyncArbiter<A>
impl<A> Unpin for SyncArbiter<A>
impl<A> !UnwindSafe for SyncArbiter<A>
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcepub fn borrow_mut(&mut self) -> &mut T
pub fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> FutureExt for T where
T: Future + ?Sized,
impl<T> FutureExt for T where
T: Future + ?Sized,
sourcefn map<U, F>(self, f: F) -> Map<Self, F> where
F: FnOnce(Self::Output) -> U,
fn map<U, F>(self, f: F) -> Map<Self, F> where
F: FnOnce(Self::Output) -> U,
Map this future’s output to a different type, returning a new future of the resulting type. Read more
sourcefn map_into<U>(self) -> MapInto<Self, U> where
Self::Output: Into<U>,
fn map_into<U>(self) -> MapInto<Self, U> where
Self::Output: Into<U>,
Map this future’s output to a different type, returning a new future of the resulting type. Read more
sourcefn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where
F: FnOnce(Self::Output) -> Fut,
Fut: Future,
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where
F: FnOnce(Self::Output) -> Fut,
Fut: Future,
Chain on a computation for when a future finished, passing the result of
the future to the provided closure f
. Read more
sourcefn left_future<B>(self) -> Either<Self, B> where
B: Future<Output = Self::Output>,
fn left_future<B>(self) -> Either<Self, B> where
B: Future<Output = Self::Output>,
Wrap this future in an Either
future, making it the left-hand variant
of that Either
. Read more
sourcefn right_future<A>(self) -> Either<A, Self> where
A: Future<Output = Self::Output>,
fn right_future<A>(self) -> Either<A, Self> where
A: Future<Output = Self::Output>,
Wrap this future in an Either
future, making it the right-hand variant
of that Either
. Read more
sourcefn into_stream(self) -> IntoStream<Self>
fn into_stream(self) -> IntoStream<Self>
Convert this future into a single element stream. Read more
sourcefn flatten(self) -> Flatten<Self> where
Self::Output: Future,
fn flatten(self) -> Flatten<Self> where
Self::Output: Future,
Flatten the execution of this future when the output of this future is itself another future. Read more
sourcefn flatten_stream(self) -> FlattenStream<Self> where
Self::Output: Stream,
fn flatten_stream(self) -> FlattenStream<Self> where
Self::Output: Stream,
Flatten the execution of this future when the successful result of this future is a stream. Read more
sourcefn fuse(self) -> Fuse<Self>
fn fuse(self) -> Fuse<Self>
Fuse a future such that poll
will never again be called once it has
completed. This method can be used to turn any Future
into a
FusedFuture
. Read more
sourcefn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnOnce(&Self::Output),
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnOnce(&Self::Output),
Do something with the output of a future before passing it on. Read more
sourcefn unit_error(self) -> UnitError<Self>
fn unit_error(self) -> UnitError<Self>
Turns a Future<Output = T>
into a
TryFuture<Ok = T, Error = ()
>. Read more
sourcefn never_error(self) -> NeverError<Self>
fn never_error(self) -> NeverError<Self>
Turns a Future<Output = T>
into a
TryFuture<Ok = T, Error = Never
>. Read more
sourcefn poll_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Self::Output> where
Self: Unpin,
fn poll_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Self::Output> where
Self: Unpin,
A convenience for calling Future::poll
on Unpin
future types.
sourcefn now_or_never(self) -> Option<Self::Output>
fn now_or_never(self) -> Option<Self::Output>
Evaluates and consumes the future, returning the resulting output if
the future is ready after the first call to Future::poll
. Read more
sourceimpl<F> IntoFuture for F where
F: Future,
impl<F> IntoFuture for F where
F: Future,
type Output = <F as Future>::Output
type Output = <F as Future>::Output
into_future
)The output that the future will produce on completion.
type Future = F
type Future = F
into_future
)Which kind of future are we turning this into?
sourcepub fn into_future(self) -> <F as IntoFuture>::Future
pub fn into_future(self) -> <F as IntoFuture>::Future
into_future
)Creates a future from a value.
sourceimpl<F, A> WrapFuture<A> for F where
F: Future,
A: Actor,
impl<F, A> WrapFuture<A> for F where
F: Future,
A: Actor,
type Future = FutureWrap<F, A>
type Future = FutureWrap<F, A>
The future that this type can be converted into.
sourcefn into_actor(self, _: &A) -> Self::Future
fn into_actor(self, _: &A) -> Self::Future
Convert normal future to a ActorFuture