如何修复多线程代码？

我没有运行它，但纯粹是出于一般原因：chank.clone它不会克隆它所包含的对象。因此，链接的生命周期chank_local等于参数 中的链接的生命周期input。关键字move无法移位，chank_local因为该值包含生命周期与其自身不同且不同于 的引用'static。

未经测试！

您不需要克隆该块，而是复制该块中的所有值：

let chank_local: Vec<String> = chank.iter().map(|s:&&str| (*s).to_owned()).collect();

该指令move会将生成的行传递给作为参数的闭包spawn，并且当闭包完成时，内存将被释放。

    //Я русский.
use std::collections::HashMap;
 
pub fn frequency(input: &[&str], worker_count: usize) -> HashMap<char, usize> {
    let mut mp = HashMap::new();
    if input.is_empty() { return mp; }
 
    // создаём канал
    let (tx, rx) = std::sync::mpsc::channel();
    // вектор для хранения дескрипторов потоков
    let mut hndls = Vec::new();
    {
        // вычисляем количество потоков и размер порции
        let mut portion = 5; //минимальная порция
        let len = input.len();
        let mut cnt = (len as f64 / portion as f64 + 0.5).round() as usize;
        cnt = if cnt < worker_count {cnt} else {worker_count};
        portion = (len as f64 / cnt as f64 + 0.5).round() as usize;
        
 
        // преобразование ссылки в адрес, для передачи в другой поток
        let ptr = std::ptr::addr_of!(input);
        let p_addr = ptr as usize;
 
        for i in 0..cnt {
            let tx_local = tx.clone();
            
            let handl = std::thread::spawn(move || {
                let mut mp_local = HashMap::new();
 
                // преобразование адреса в ссылку и получение слайса фрагмента 
                let ptr = p_addr as *const &[&str];
                let m = unsafe { *ptr };
                let chank  = &m[i*portion..if (i+1)*portion<len {(i+1)*portion} else {len}];
 
 
                for s in chank {
                    for mut ch in s.chars() {
                        if !ch.is_alphabetic() {
                            continue;
                        } 
                        if let Some(c) = ch.to_lowercase().nth(0) { ch = c; } else { continue; }
 
                        if let Some(val) = mp_local.get_mut(&ch) {
                            *val += 1;
                        } else {
                            mp_local.insert(ch, 1);
                        }
                    }
                }
 
                if let Err(e) = tx_local.send(mp_local) {
                    eprintln!("Ошибка записи в канал потоком {i}: {e}");
                }
            });
 
            hndls.push(handl);
        }
    }
    
    drop(tx);
 
    for mp_local in rx {
        for (k,v) in mp_local {
            if let Some(val) = mp.get_mut(&k) {
                *val += v;
            } else {
                mp.insert(k, v);
            }
        }
    }
 
    for handl in hndls {
        handl.join().unwrap();
    }
    
    mp
}

或者像这样：

//Я русский.
use std::collections::HashMap;
 
use futures::executor::block_on;
 
async fn task(p_addr: usize, b: usize, e: usize) ->Result<HashMap<char,usize>, String> {
    let mut mp = HashMap::new();
 
    // преобразование адреса в ссылку и получение слайса фрагмента 
    let ptr = p_addr as *const &[&str];
    let m = unsafe { *ptr };
    let chank = &m[b..e];
 
    for s in chank {
        for mut ch in s.chars() {
            if !ch.is_alphabetic() { continue; }
            if let Some(c) = ch.to_lowercase().nth(0) { ch = c; } else { continue; } 
            if let Some(val) = mp.get_mut(&ch) {
                *val += 1;
            } else {
                mp.insert(ch, 1);
            }
        }
    }
 
    Ok(mp)
}
 
async fn help(input: &[&str], worker_count: usize, mp: &mut HashMap<char, usize>)  {
    if input.is_empty() { return; }
 
    // вектор для хранения futures
    let mut futs = Vec::new();
    {
        // вычисляем количество заданий и размер порции
        let mut portion = 5; //минимальная порция
        let len = input.len();
        let mut cnt = (len as f64 / portion as f64 + 0.5).round() as usize;
        cnt = if cnt < worker_count {cnt} else {worker_count};
        portion = (len as f64 / cnt as f64 + 0.5).round() as usize;
        
 
        // преобразование ссылки в адрес, для передачи в другой поток
        let ptr = std::ptr::addr_of!(input);
        let p_addr = ptr as usize;
 
        for i in 0..cnt {                
            let future = task(p_addr, i*portion, if (i+1)*portion<len {(i+1)*portion} else {len});
            futs.push(future);
        }
    }
    let mps = futures::future::try_join_all(futs).await.unwrap();
    for mp_l in mps {
        for (k,v) in mp_l {
            if let Some(val) = mp.get_mut(&k) {
                *val += v;
            } else {
                mp.insert(k, v);
            }
        }
    }    
}
 
pub fn frequency(input: &[&str], worker_count: usize) -> HashMap<char, usize> {
    let mut mp = HashMap::new();
    block_on(help(input, worker_count, &mut mp));
 
    mp
}