在 Rust 中的 application.run 之后等待后端线程完成

Question

我想等待一个后端线程（Like this，但在我的情况下，后端管理一个我想在应用程序实际退出之前正确关闭的数据库）在application.run() 完成后完成（例如加入它）。

• My actual non working main.rs（闭包必须是非mut）
• the thread to wait for

use gio::prelude::*;
use gtk::prelude::*;
use gtk::{ApplicationWindow, Label};
use std::env::args;
use std::thread;

fn main() {
    let application = gtk::Application::new(
        Some("com.github.gtk-rs.examples.communication_thread"),
        Default::default(),
    )
    .expect("Initialization failed...");

    let (thr, mut receiver) = start_communication_thread();

    application.connect_activate(move |application| {
        build_ui(application, receiver.take().unwrap())
    });
    application.run(&args().collect::<Vec<_>>());
    thr.join();
}

fn build_ui(application: &gtk::Application, receiver: glib::Receiver<String>) {
    let window = ApplicationWindow::new(application);
    let label = Label::new(None);
    window.add(&label);

    spawn_local_handler(label, receiver);
    window.show_all();
}

/// Spawn channel receive task on the main event loop.
fn spawn_local_handler(label: gtk::Label, receiver: glib::Receiver<String>) {
    receiver.attach(None, move |item| {
        label.set_text(&item);
        glib::Continue(true)
    });
}

/// Spawn separate thread to handle communication.
fn start_communication_thread() -> (thread::JoinHandle<()>, Option<glib::Receiver<String>>) {
    let (sender, receiver) = glib::MainContext::channel(glib::PRIORITY_DEFAULT);

    let thr = thread::spawn(move || {
        let mut counter = 0;
        loop {
            let data = format!("Counter = {}!", counter);
            println!("Thread received data: {}", data);
            if sender.send(data).is_err() {
                break
            }
            counter += 1;
            thread::sleep(std::time::Duration::from_millis(100));
        }
    });
    (thr, Some(receiver))
}

如上所述，剩下的唯一错误是application.connect_activate() 采用Fn 闭包，当前实现是FnMut。

Answer 1

错误信息是：

error[E0596]: cannot borrow `receiver` as mutable, as it is a captured variable in a `Fn` closure
  --> src/main.rs:17:31
   |
17 |         build_ui(application, receiver.take().unwrap())
   |                               ^^^^^^^^ cannot borrow as mutable

所以你不能可变地使用“receiver”，这是你take()它的内容所必需的。

但是如果你将接收器包装在Cell 中，那么你可以可变地访问不可变的Cell 的内容。所以直接在start_communication_thread()后面加上这一行：

    let receiver = Cell::new(receiver);

可能有一些更正确的答案，因为我只是 Rust 的初学者，但至少它似乎有效。

请注意，这会将take() 调用更改为针对Cell 而不是Option 调用，其实现具有相同的效果，将Cell 的内容替换为None。