问线程间传递hashmap的通道|卡住循环|生锈

EN

use std::collections::HashMap;
use std::thread;
use std::sync::mpsc;
use std::str;

pub fn frequency(input: &[&str], worker_count: usize) -> HashMap<char, usize> {
   
   // Empty case 
   if input.is_empty() {
       return HashMap::new();
   }

   // Flatten input, set workload for each thread, create hashmap to catch results
   let mut flat_input = input.join("");
   let workload = input.len() / worker_count;
   let mut final_map: HashMap<char, usize> = HashMap::new();

   
   let (tx, rx) = mpsc::channel();
   for _i in 0..worker_count {
       let task = flat_input.split_off(flat_input.len() - workload);
       let tx_clone = mpsc::Sender::clone(&tx);

       
       // Separate threads ---------------------------------------------
       thread::spawn(move || {
          let mut partial_map: HashMap<char, usize> = HashMap::new();
          for letter in task.chars() {
              match partial_map.remove(&letter) {
                  Some(count) => {
                      partial_map.insert(letter, count + 1);
                  },
                  None => {
                      partial_map.insert(letter, 1);
                  }
              }
          }
          tx_clone.send(partial_map).expect("Didn't work fool");
       });
       // --------------------------------------------------  
       
   }
   
   // iterate through the returned hashmaps to update the final map
   for received in rx {
       for (key, value) in received {
           match final_map.remove(&key) {
               Some(count) => {
                   final_map.insert(key, count + value);
               },
               None => {
                   final_map.insert(key, value);
               }  
           }
       }
   }
   
   return final_map;
}