理想地，这将被固定在最里面的部分。你的websocket库可能有一个非阻塞的同步方式来读取websocket，你可以在绘制圆圈之间检入，而不产生任何东西，可能不使用任何异步。
另一种方法是使用channel生成websocket函数。这绝对可以以非阻塞同步方式使用。你可以在websocket任务中存储一个Sender，在模型中存储一个Receiver。

use std::sync::mpsc;
struct Model {
    // you can create your own message type to use here instead of `String`
    receiver: mpsc::Receiver<String>, 
}

let (sender, receiver) = mpsc::channel();
let mut model = Model { receiver };
tokio::spawn(listen_to_websocket(sender));

然后在画圆之间，可以检查通道。

fn update(_app: &App, model: &mut Model, _update: Update) {
    draw_circles();
    if let Ok(message) = model.receiver.try_recv() {
        handle_message(message);
    }
}

您的websocket库可能有非常类似的东西，但是如果您的websocket消息需要大量处理，您可能仍然希望使用通道。此外，你可能想使用tokio的一个通道来代替，特别是如果你在循环中有其他异步的事情要做的话。
如果你还需要向websocket发送数据，你可以在相反的方向上创建另一个通道进行通信。
你可以做的另一件事是将你的模型存储在一个Arc中，已经有很多关于this one的帖子了。这些应用于std::thread::spawn的方式与tokio::spawn相同。
除了你的直接问题，你还需要避免阻塞你的异步运行时。当调用run时会发生这种情况，它将永远阻塞。Tokio有一些函数来生成阻塞任务。Nannou在run文档中这样说：
如果您希望保持跨平台友好性，我们建议您在主线程上调用此函数，因为某些平台要求其应用程序的事件循环和窗口在主线程上初始化。
这意味着你应该使用tokio的block_in_place。

#[tokio::main]
async fn main() {
    tokio::task::block_in_place(|| nannou::app(model).update(update).run());
}

还要确保你没有阻止websocket任务。如果需要阻塞，可以使用tokio::task::spawn_blocking而不是tokio::spawn。

更新

这里有一个非异步版本，可以用来代替只使用tungstenite的tokio::spawn调用。不需要东京。然后，您可以将返回的Receiver合并到Model中，并在第二个代码块中像上面一样调用try_recv。

use std::sync::mpsc;

// You can create your own message type to use here instead of `String`
type ChannelMessage = String;

// Call this when creating the Model
pub fn create_websocket_thread() -> mpsc::Receiver<ChannelMessage> {
    let (sender, receiver) = mpsc::channel();
    std::thread::spawn(move || {
        handle_connections(sender);
    });
    receiver
}

// Work to do in the websocket thread
fn handle_connections(sender: mpsc::Sender<ChannelMessage>) {
    let mut client = tungstenite::connect("ws://127.0.0.1:5000").unwrap().0;
    loop {
        let message = match client.read_message() {
            Ok(tungstenite::Message::Text(m)) => m,
            Ok(_) => (),
            Err(e) => panic!("{e}"),
        };
        let message = process_message(message);
        sender.send(message).unwrap();
    }
}

// Do whatever conversion you need
fn process_message(message: String) -> ChannelMessage {
    message
}