title: Spawning threads and keeping data from them
body: <p>This is a super contrived example that shows what I want to do; I have a HashMap that I want to push data in to, but I want to do it in a set of threads - the real example is that I'm connecting to a remote service inside the <code>thread::spawn</code> and so I want to have all of it happen in the background as much as possible so it doesn't block the primary thread.</p>
  
  <p>I'm not sure how to refactor my code to allow what I'm wanting to do - any suggestions would be helpful!</p>
  
  <pre><code>let mut item_array : HashMap&lt;i32, i32&gt; = HashMap::new();
  let mut array: [i32; 3] = [0, 1, 2];
  
  for item in &amp;array {
      thread::spawn(|| {
          item_array.insert(*item, *item);
      });
  }
  println!("{:?}", item_array);
  </code></pre>
  
  <p>The errors I receive are below</p>
  
  <pre><code>error[E0597]: `array` does not live long enough
     --&gt; src/main.rs:87:17
      |
  87  |     for item in &amp;array {
      |                 ^^^^^^
      |                 |
      |                 borrowed value does not live long enough
      |                 argument requires that `array` is borrowed for `'static`
  ...
  153 | }
      | - `array` dropped here while still borrowed
  
  error[E0499]: cannot borrow `item_array` as mutable more than once at a time
    --&gt; src/main.rs:88:23
     |
  88 |           thread::spawn(|| {
     |           -             ^^ mutable borrow starts here in previous iteration of loop
     |  _________|
     | |
  89 | |             item_array.insert(*item, *item);
     | |             ---------- borrows occur due to use of `item_array` in closure
  90 | |         });
     | |__________- argument requires that `item_array` is borrowed for `'static`
  
  error[E0373]: closure may outlive the current function, but it borrows `item`, which is owned by the current function
    --&gt; src/main.rs:88:23
     |
  88 |         thread::spawn(|| {
     |                       ^^ may outlive borrowed value `item`
  89 |             item_array.insert(*item, *item);
     |                                ---- `item` is borrowed here
     |
  note: function requires argument type to outlive `'static`
    --&gt; src/main.rs:88:9
     |
  88 | /         thread::spawn(|| {
  89 | |             item_array.insert(*item, *item);
  90 | |         });
     | |__________^
  help: to force the closure to take ownership of `item` (and any other referenced variables), use the `move` keyword
     |
  88 |         thread::spawn(move || {
     |                       ^^^^^^^
  
  error[E0373]: closure may outlive the current function, but it borrows `item_array`, which is owned by the current function
    --&gt; src/main.rs:88:23
     |
  88 |         thread::spawn(|| {
     |                       ^^ may outlive borrowed value `item_array`
  89 |             item_array.insert(*item, *item);
     |             ---------- `item_array` is borrowed here
     |
  note: function requires argument type to outlive `'static`
    --&gt; src/main.rs:88:9
     |
  88 | /         thread::spawn(|| {
  89 | |             item_array.insert(*item, *item);
  90 | |         });
     | |__________^
  help: to force the closure to take ownership of `item_array` (and any other referenced variables), use the `move` keyword
     |
  88 |         thread::spawn(move || {
     |                       ^^^^^^^
  
  error[E0502]: cannot borrow `item_array` as immutable because it is also borrowed as mutable
    --&gt; src/main.rs:92:22
     |
  88 |           thread::spawn(|| {
     |           -             -- mutable borrow occurs here
     |  _________|
     | |
  89 | |             item_array.insert(*item, *item);
     | |             ---------- first borrow occurs due to use of `item_array` in closure
  90 | |         });
     | |__________- argument requires that `item_array` is borrowed for `'static`
  91 |       }
  92 |       println!("{:?}", item_array);
     |                        ^^^^^^^^^^ immutable borrow occurs here
  </code></pre>