Sharing a struct with trait objects as properties across threads

by

I find the error message pretty straightforward:

  • the trait std::marker::Send is not implemented for Expr + 'static
  • required because of the requirements on the impl of std::marker::Send for std::sync::Arc<Expr + 'static>
  • required because it appears within the type Container
  • required because of the requirements on the impl of std::marker::Send for std::sync::Arc<Container>
  • required because it appears within the type [closure@src/main.rs:64:33: 67:6 container1:std::sync::Arc<Container>]
  • required by std::thread::spawn

You are trying to move your Arc<Container> to another thread, but it contains an Arc<Expr + 'static>, which cannot be guaranteed to be safely sent (Send) or shared (Sync) across threads.

Either add Send and Sync as supertraits to Expr:

pub trait Expr: Send + Sync { /* ... */ }

Or add them as trait bounds to your trait objects:

pub struct AddExpr {
    expr1: Box<Expr + Send + Sync>,
    expr2: Box<Expr + Send + Sync>,
}

impl AddExpr {
    pub fn new(expr1: Box<Expr + Send + Sync>, expr2: Box<Expr + Send + Sync>) -> Self {
        Self { expr1, expr2 }
    }
}

struct Container {
    x: i32,
    cached_expr: Arc<Expr + Send + Sync>,
}

See also:

More Related Contents:

  1. Why can’t I store a value and a reference to that value in the same struct?
  2. What are non-lexical lifetimes?
  3. The compiler suggests I add a ‘static lifetime because the parameter type may not live long enough, but I don’t think that’s what I want
  4. How can I create my own data structure with an iterator that returns mutable references?
  5. Lifetime error when creating a function that returns a value implementing serde::Deserialize
  6. Why does linking lifetimes matter only with mutable references?
  7. Why is adding a lifetime to a trait with the plus operator (Iterator + ‘a) needed?
  8. Cannot infer an appropriate lifetime for autoref due to conflicting requirements
  9. When is it useful to define multiple lifetimes in a struct?
  10. Lifetime troubles sharing references between threads
  11. Moved variable still borrowing after calling `drop`?
  12. What is lifetime elision in very simple terms?
  13. “borrowed value does not live long enough” when using the builder pattern
  14. How can this instance seemingly outlive its own parameter lifetime?
  15. How do I specify lifetime parameters in an associated type?
  16. How to operate on 2 mutable slices of a Rust array?
  17. When returning the outcome of consuming a StdinLock, why was the borrow to stdin retained?
  18. Why does my variable not live long enough?
  19. Why is the bound `T: ‘a` required in order to store a reference `&’a T`?
  20. Why can’t I return an &str value generated from a String?
  21. Type mismatches resolving a closure that takes arguments by reference
  22. How to fix lifetime error when function returns a serde Deserialize type?
  23. Why does Rust disallow mutable aliasing?
  24. Extend lifetime of variable
  25. Why does the Rust compiler request I constrain a generic type parameter’s lifetime (error E0309)?
  26. Why does Iterator::take_while take ownership of the iterator?
  27. When should I implement std::convert::From vs std::convert::Into?
  28. “parameter `’a` is never used” error when ‘a is used in type parameter bound
  29. How can I define an async method in a trait?
  30. Lazy sequence generation in Rust

Leave a Comment