Multithreading 向量中函数的线程调用

我有一个

EventRegistry

，人们可以使用它注册事件侦听器。然后在广播事件时调用相应的侦听器。但是，当我尝试对它进行多线程处理时，它不会编译。我怎样才能让代码正常工作

使用std:：collections:：HashMap；
使用std：：线程；
结构事件注册表
}
恳求{
fn new（）->EventRegistry{
listeners.push（listener）；
返回
},
无=>{}
};
让mut listeners=Vec:：具有_容量（1）；
listeners.push（listener）；
self.event_listeners.insert（事件，侦听器）；
}
fn广播事件（&mut self，事件：&str）{
匹配self.event\u侦听器.get（事件）{
一些（听众）=>{
用于listeners.iter（）中的侦听器{
让|=线程：：生成（| |{
监听器（）；
});
}
}
无=>{}
}
}
}
fn main（）{
让mut main_registry=EventRegistry:：new（）；
主注册表。添加事件监听器（“玩家移动”，框：：新建（| |）{
println！（“嘿，看，玩家动了！”）；
}));
主注册表。广播事件（“玩家移动”）；
}

（不确定是否最小，但会产生错误）

如果我使用

thread:：scoped

，它也可以工作，但这是不稳定的，我认为它只能工作，因为它会立即连接回主线程。

更新了问题 我的意思是“用他们自己的思路给他们打电话”

如果可能的话，最简单的方法就是避免使用

Fn*

特征。如果您知道您只使用完整的函数，那么很简单：

use std::thread;

fn a() { println!("a"); }
fn b() { println!("b"); }

fn main() {
    let fns = vec![a as fn(), b as fn()];

    for &f in &fns {
        thread::spawn(move || f());
    }

    thread::sleep_ms(500);
}

如果出于某种原因（比如你想接受闭包）不能使用它，那么你需要更明确一点并使用

Arc

：

use std::thread;
use std::sync::Arc;

fn a() { println!("a"); }
fn b() { println!("b"); }

fn main() {
    let fns = vec![
        Arc::new(Box::new(a) as Box<Fn() + Send + Sync>),
        Arc::new(Box::new(b) as Box<Fn() + Send + Sync>),
    ];

    for f in &fns {
        let my_f = f.clone();
        thread::spawn(move || my_f());
    }

    thread::sleep_ms(500);
}

---

Edited=）但不确定是否足够好。请注意，Rust样式是4-空格缩进。请发布实际错误。

fn a() { println!("a"); }
fn b() { println!("b"); }

fn main() {
    let fns = vec![Box::new(a) as Box<Fn()>, Box::new(b) as Box<Fn()>];
    fns[0]();
    fns[1]();
    fns[0]();
    fns[1]();
}