Warm heaters for winter.

heate.rs

extern crate rand;
use rand::Rng;

use std::thread;
use std::sync::{Arc};
use std::sync::atomic::{AtomicIsize, Ordering};
use std::iter::FromIterator;

fn main() {
    println!("Heater turned on!");
    
    let degree_of_warmness = 8;

    let fairly_large: usize = 1024*1024*128;
    let chunk_shared: Vec<_> = Arc::new((0..fairly_large).map(|_| AtomicIsize::new(0 as isize)).collect());

    println!("Fuel loaded!");
    
    let threads:Vec<_> = (0..degree_of_warmness)
        .map(|id| {
            let chunk = chunk_shared.clone();

            thread::Builder::new()
                .name(format!("heater_thread {}", id))
                .spawn(move || {
                    println!("heater {} is running!", id);
                    
                    let mut rng = rand::IsaacRng::new_unseeded();
                    while true {
                        let idx:usize = rng.gen_range(0, fairly_large);
                        let some_random:isize = rng.gen_range(-10, 10);
                        
                        let loaded = chunk[idx].load(Ordering::Acquire);
                        chunk[idx].store(loaded + some_random, Ordering::Release);
                    }
                })
        })
        .filter(|thread_result| thread_result.is_ok())
        .map(|thread_result| thread_result.unwrap())
        .collect();

    for thread in threads {
        thread.join().unwrap();
    }
}