Parallel threads partitioned array in Rust

Hi im trying to run parallel computation in separate threads to determine the sum of an array. I'm new to Rust and have coded with C/C++/Java before but I want to bang my head against the wall since Rust is still in Alpha.

I've literally thrown everything and the garbage sink at this program and I was hoping I could receive some guidance.

Sorry my code is sloppy but I will clean it up when it is a finished product. Ignore all poorly named variables/inconsistent spacing/etc.

Much thanks.

use std::io;
use std::rand;
use std::sync::mpsc::{Sender, Receiver};
use std::sync::mpsc;
use std::thread::Thread;

static NTHREADS: usize = 4;
static NPROCS: usize = 10;

fn main() {
let mut a = [0; 10]; // a: [i32; 10]
let mut endpoint = a.len() / NTHREADS;
let mut remElements = a.len() % NTHREADS;


for x in 0..a.len() {
let secret_number = (rand::random::<i32>() % 100) + 1;
a[x] = secret_number;
println!("{}", a[x]);
}
let mut b = a;
let mut x = 0;

check_sum(&mut a);
// serial_sum(&mut b);

// Channels have two endpoints: the `Sender<T>` and the `Receiver<T>`,
// where `T` is the type of the message to be transferred
// (type annotation is superfluous)
let (tx, rx): (Sender<i32>, Receiver<i32>) = mpsc::channel();
let mut scale: usize = 0;

for id in 0..NTHREADS {
    // The sender endpoint can be copied
    let thread_tx = tx.clone();
    // Each thread will send its id via the channel

   Thread::spawn(move || {
   // The thread takes ownership over `thread_tx`
   // Each thread queues a message in the channel
   let numTougherThreads: usize = NPROCS % NTHREADS;
   let numTasksPerThread: usize = NPROCS / NTHREADS;
   let mut lsum = 0;

   if id < numTougherThreads {
   let mut q = numTasksPerThread+1;
   lsum = 0;

   while q > 0 {
   lsum = lsum + a[scale];
   scale+=1;
   q = q-1;
 }
  println!("Less than numToughThreads lsum: {}", lsum);
}
   if id >= numTougherThreads {
   let mut z = numTasksPerThread;
   lsum = 0;

   while z > 0 {
   lsum = lsum + a[scale];
   scale +=1;
   z = z-1;
 }    
 println!("Greater than numToughthreads lsum: {}", lsum);
 }
   // Sending is a non-blocking operation, the thread will continue
        // immediately after sending its message
   println!("thread {} finished", id);
   thread_tx.send(lsum).unwrap();
     });

 }

// Here, all the messages are collected
  let mut globalSum = 0;
  let mut ids = Vec::with_capacity(NTHREADS);
  for _ in 0..NTHREADS {
    // The `recv` method picks a message from the channel
  // `recv` will block the current thread if there no messages      available
    ids.push(rx.recv());
 }
println!("Global Sum: {}", globalSum);
// Show the order in which the messages were sent

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

}

So far I've gotten it to do this much. Can't figure out why threads 0 and 1 have the same sum as well as 2 and 3 doing the same thing:

 -5
 -49
 -32
 99
 45
 -65
 -64
 -29
 -56
 65
 CheckSum is -91
 Greater than numTough lsum: -54
 thread 2 finished
 Less than numTough lsum: -86
 thread 1 finished
 Less than numTough lsum: -86
 thread 0 finished
 Greater than numTough lsum: -54
 thread 3 finished
 Global Sum: 0
 ids: [Ok(-86), Ok(-86), Ok(-54), Ok(-54)]