Lifetime of variables passed to a new thread

by

The problem lies in spawning a background thread. When you call thread::spawn you effectively have to pass ownership of any resource used in it to the thread, as it might run indefinitely, which means that its lifetime must be 'static.

There are two options to resolve that: the simplest one would be to pass ownership. Your code here

let new_arg = arg.to_string() + "foo";
t.send(arg);

looks like you actually wanted to send new_arg, in which case you could just create the owned result of arg.to_string() before spawning the thread, thus eliminating the need to pass the reference arg.

Another slightly more involved idea, that might be useful at some point though, are scoped threads as implemented in crossbeam for example. These are bound to an explicit scope, where you spawn them and are joined together at the end. This looks somewhat like this:

crossbeam::scope(|scope| {
    scope.spawn(|| {
        println!("Hello from a scoped thread!");
    });
});

Have a look at the docs for further details.

More Related Contents:

  1. What is the difference between iter and into_iter?
  2. How does for syntax differ from a regular lifetime bound?
  3. How to get a reference to a concrete type from a trait object?
  4. How do I return a reference to something inside a RefCell without breaking encapsulation?
  5. Conditionally iterate over one of several possible iterators
  6. Why is this match pattern unreachable when using non-literal patterns?
  7. Is there any way to create a type alias for multiple traits?
  8. What’s an idiomatic way to print an iterator separated by spaces in Rust?
  9. Proper way to return a new string in Rust
  10. What are move semantics in Rust?
  11. How do I return an instance of a trait from a method?
  12. “borrowed value does not live long enough” seems to blame the wrong thing
  13. Is it possible to make a type only movable and not copyable?
  14. How to use struct self in member method closure
  15. How do I call a function through a member variable?
  16. Why are Rust executables so huge?
  17. How do you pass a Rust function as a parameter?
  18. How do I implement a trait with a generic method?
  19. How can I create a function with a variable number of arguments?
  20. How do I fix “cannot find derive macro in this scope”?
  21. Why is the bound `T: ‘a` required in order to store a reference `&’a T`?
  22. Type mismatches resolving a closure that takes arguments by reference
  23. How do I disambiguate traits in Rust?
  24. How do I change a function’s qualifiers via conditional compilation?
  25. How do I specify that a struct field must implement a trait?
  26. What does Rust’s unary || (parallel pipe) mean?
  27. How to create and write to memory mapped files?
  28. Downcast traits inside Rc for AST manipulation
  29. How to check in Rust if architecture is 32 or 64 bit?
  30. Is there any way to restrict a generic type to one of several types?

Leave a Comment