使用异步(tokio) rust-websocket在客户端之间共享可变状态

[dependencies]
tokio = { version = "x.x.x", features = ["full"] }
websocket = "x.x.x"

use tokio::net::TcpListener;
use websocket::{Server, Message};

#[tokio::main]
async fn main() {
    let listener = TcpListener::bind("127.0.0.1:8080").await.unwrap();
    let server = Server::bind("127.0.0.1:8080").await.unwrap();

    while let Ok((stream, _)) = listener.accept().await {
        tokio::spawn(async move {
            let mut websocket = server.accept(stream).await.unwrap();

            while let Ok(msg) = websocket.recv().await {
                // 处理接收到的消息
                match msg {
                    Message::Text(text) => {
                        // 处理文本消息
                    }
                    Message::Binary(data) => {
                        // 处理二进制消息
                    }
                    _ => {}
                }
            }
        });
    }
}

use websocket::{ClientBuilder, Message};

#[tokio::main]
async fn main() {
    let client = ClientBuilder::new("ws://127.0.0.1:8080")
        .unwrap()
        .connect_insecure()
        .await
        .unwrap();

    let (mut sender, mut receiver) = client.split();

    // 发送消息
    sender.send(Message::text("Hello, server!")).await.unwrap();

    // 接收消息
    while let Ok(msg) = receiver.recv().await {
        // 处理接收到的消息
        match msg {
            Message::Text(text) => {
                // 处理文本消息
            }
            Message::Binary(data) => {
                // 处理二进制消息
            }
            _ => {}
        }
    }
}

use std::sync::{Arc, Mutex};

#[tokio::main]
async fn main() {
    let shared_state = Arc::new(Mutex::new(0));

    // 在处理接收到的消息时，可以对共享状态进行修改
    let mut state = shared_state.lock().unwrap();
    *state += 1;
}