How can I pass a reference to a stack variable to a thread?

by

The thread support in the standard library allows the created threads to outlive the thread that created them; that’s a good thing! However, if you were to pass a reference to a stack-allocated variable to one of these threads, there’s no guarantee that the variable will still be valid by the time the thread executes. In other languages, this would allow the thread to access invalid memory, creating a pile of memory safety issues.

Fortunately, we aren’t limited to the standard library. At least two crates provide scoped threads — threads that are guaranteed to exit before a certain scope ends. These can ensure that stack variables will be available for the entire duration of the thread:

There are also crates that abstract away the low-level details of “threads” but allow you to accomplish your goals:

Here are examples of each. Each example spawns a number of threads and mutates a local vector in place with no locking, no Arc, and no cloning. Note that the mutation has a sleep call to help verify that the calls are happening in parallel.

You can extend the examples to share a reference to any type which implements Sync, such as a Mutex or an Atomic*. Using these would introduce locking, however.

crossbeam

use crossbeam; // 0.6.0
use std::{thread, time::Duration};

fn main() {
    let mut vec = vec![1, 2, 3, 4, 5];

    crossbeam::scope(|scope| {
        for e in &mut vec {
            scope.spawn(move |_| {
                thread::sleep(Duration::from_secs(1));
                *e += 1;
            });
        }
    })
    .expect("A child thread panicked");

    println!("{:?}", vec);
}

rayon

use rayon::iter::{IntoParallelRefMutIterator, ParallelIterator}; // 1.0.3
use std::{thread, time::Duration};

fn main() {
    let mut vec = vec![1, 2, 3, 4, 5];

    vec.par_iter_mut().for_each(|e| {
        thread::sleep(Duration::from_secs(1));
        *e += 1;
    });

    println!("{:?}", vec);
}

the client is required to box the connection in an Arc when it is internal to the library that the code is parallelized

Perhaps you can hide your parallelism better then? Could you accept the logger and then wrap it in an Arc / Mutex before handing it off to your threads?

More Related Contents:

  1. Thread references require static lifetime?
  2. Why can’t I store a value and a reference to that value in the same struct?
  3. Is there any way to return a reference to a variable created in a function?
  4. Why are explicit lifetimes needed in Rust?
  5. Why does linking lifetimes matter only with mutable references?
  6. How do I implement the Add trait for a reference to a struct?
  7. How do I share a mutable object between threads using Arc?
  8. Iterator returning items by reference, lifetime issue
  9. How do I run parallel threads of computation on a partitioned array?
  10. Rust mpsc::Sender cannot be shared between threads?
  11. Rust lifetime error expected concrete lifetime but found bound lifetime
  12. What is a race condition?
  13. How can I create my own data structure with an iterator that returns mutable references?
  14. How many threads is too many?
  15. How to create threads in nodejs
  16. If threads share the same PID, how can they be identified?
  17. How to avoid writing duplicate accessor functions for mutable and immutable references in Rust?
  18. What does threadsafe mean?
  19. How to articulate the difference between asynchronous and parallel programming?
  20. “borrowed value does not live long enough” when using the builder pattern
  21. How many memory barriers instructions does an x86 CPU have?
  22. Simple Thread Sample Delphi
  23. How would you define a pool of goroutines to be executed at once?
  24. How JavaFX application thread works?
  25. Is non-blocking I/O really faster than multi-threaded blocking I/O? How?
  26. Why is the bound `T: ‘a` required in order to store a reference `&’a T`?
  27. Python 2.7: streaming HTTP server supporting multiple connections on one port
  28. Type mismatches resolving a closure that takes arguments by reference
  29. Are “data races” and “race condition” actually the same thing in context of concurrent programming
  30. Simple Deadlock Examples

Leave a Comment