Is State cloned for each request?

[soasada]

Hi, I'm a little bit confused with clone and Arc when using with_state function.

I have the following AppState:

use tokio::sync::mpsc;

#[derive(Clone)]
pub struct ActorHandle {
    sender: mpsc::Sender<ActorMessage>,
}

impl ActorHandle {
  pub async fn send_msg(&self, msg: ActorMessage) {
    self.sender.send(msg).await;
  }
}

#[derive(Clone)]
pub struct AppState {
    pub actor_handle: ActorHandle,
}

When I create my axum router I create a regular AppState without Arc:

use tokio::sync::mpsc;

let (sender, receiver) = mpsc::channel(32);

let app_state = AppState {
        actor_handle: ActorHandle { sender }
};

let router = Router::new()
  .route("/foo", post(foo))
  .with_state(app_state);

Then I use it in the handler as a regular variable:

pub async fn foo(State(state): State<AppState>) -> impl IntoResponse {
  // msg creation omitted for brevity 
  state.actor_handle.send_msg(msg).await; // should I use state.clone() and then use the variable "actor_handle"?
}

Is this legal? do I need to clone or add Arc type to my state if this is my use case?

[davidpdrsn]

Yes the state is cloned for each request. Otherwise you wouldn't be able to extract an owned state.

[soasada]

Then, when are the use cases of using Arc wrapping the State?

[davidpdrsn]

If you have a state that is expensive to clone or can't be cloned then you need an Arc.

[thomasmost]

is this recommended for database pools, for example?

[davidpdrsn]

No. Pools are often arcs internally.

[thomasmost]

Got it! Thank you so much