Question

我有一个EventRegistry，人们可以使用它来注册事件监听器。然后在广播事件时调用适当的侦听器。但是，当我尝试多线程时，它不会编译。我如何使这段代码有效？

use std::collections::HashMap;
use std::thread;

struct EventRegistry<'a> {
  event_listeners: HashMap<&'a str, Vec<Box<Fn() + Sync>>>
}

impl<'a> EventRegistry<'a> {
  fn new() -> EventRegistry<'a> {
    EventRegistry {
      event_listeners: HashMap::new()
    }
  }

  fn add_event_listener(&mut self, event: &'a str, listener: Box<Fn() + Sync>) {

    match self.event_listeners.get_mut(event) {
      Some(listeners) => {
        listeners.push(listener);
        return
      },
      None => {}
    };

    let mut listeners = Vec::with_capacity(1);
    listeners.push(listener);

    self.event_listeners.insert(event, listeners);
  }

  fn broadcast_event(&mut self, event: &str) {

    match self.event_listeners.get(event) {
      Some(listeners) => {
        for listener in listeners.iter() {
          let _ = thread::spawn(|| {
            listener();
          });
        }
      }
      None => {}
    }

  }
}

fn main() {
  let mut main_registry = EventRegistry::new();

  main_registry.add_event_listener("player_move", Box::new(|| {
    println!("Hey, look, the player moved!");
  }));

  main_registry.broadcast_event("player_move");
}

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

如果我使用thread::scoped，它也会起作用，但这是不稳定的，我认为它只能起作用，因为它会立即加入主线程。

Answer 1

更新了问题

我的意思是＆＃34;在他们自己的线程中调用它们＆＃34;

最简单的方法是尽可能避免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);
}

在这里，我们可以创建一个引用计数的特征对象。我们可以在每次生成新线程时克隆trait对象（增加引用计数）。每个线程都有自己对trait对象的引用。

如果我使用thread::scoped，它也可以使用

thread::scoped非常棒;非常不幸的是，由于一些不是最好的复杂互动，它需要被标记为不稳定。

作用域线程的一个好处是线程保证以特定时间结束：当JoinGuard被删除时。这意味着允许范围内的线程包含非'static 引用，只要这些引用的持续时间超过线程！

一个产生的线程对它们的存活时间没有这样的保证;这些线程可能永远存在＆＃34;。他们所采取的任何引用也必须永远存在＆＃34;因此'static限制。

这可以解释您的原始问题。你有一个非'static生命周期的向量，但是你将指向该向量的引用交给线程。如果在线程退出之前要释放该向量，则可能会尝试访问未定义的内存，这会导致C或C ++程序崩溃。这是Rust帮你解决的！

原始问题

在向量中调用函数而不消耗它们

答案是你只需要打电话给他们：

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](); }

Playpen

线程调用向量中的函数

1 个答案:

更新了问题

原始问题