用async_std实现聊天服务器时，用不安全的方式存储全局客户端向量可以吗？

Question

我已经实现了一个聊天服务器，它存储连接的用户，如果用户发送消息，服务器会将其回传到所有其他客户端。

我有C++背景，所以我创建了一个全局static mut USERS:Vec<TcpStream>变量来存储和访问用户。

我正在处理main()中的连接用户，如下所示：

#[async_std::main]
async fn main() -> io::Result<()>{
    let listener = TcpListener::bind("127.0.0.1:14530").await?;

    loop {
        let (stream, addr) = listener.accept().await?;
        
        unsafe {
            USERS.push(stream.clone());
        }
        
        task::spawn(on_connection(stream, addr));
    }
}

on_connection函数是：

async fn on_connection(mut stream:TcpStream, addr:SocketAddr) -> io::Result<()> {
    println!("New Connection: {}", addr.to_string());

    let mut buffer = [0u8; 1024];
    loop {
        let len = stream.read(&mut buffer).await?; 

        if len > 0 {
            print!("Message from {} => {}", addr.to_string(), String::from_utf8_lossy(&buffer));
            
            unsafe {
                for mut user in USERS.clone() {
                    user.write(&buffer).await?;
                }
            }
        }
        else {
            println!("Disconnected: {}", addr.to_string());
            
            break
        }
    };

    Ok(())
}

这样使用锈菌可以吗？

我想要使应用程序安全，并使用锈菌的安全环境，而不是“不安全”。但我想不出如何存储全局用户，以便在没有不安全的情况下访问。

Answer 1

考虑到这些评论，这是我对上述实现的“安全版本”：

use std::net::SocketAddr;
use async_std::net::{TcpStream, TcpListener};
use async_std::sync::{Arc, Mutex};
use async_std::io::{ReadExt, WriteExt, Result};
use async_std::task;


async fn on_connection(mut stream:TcpStream, addr:SocketAddr, users:Arc<Mutex<Vec<TcpStream>>>) -> Result<()> {
    println!("New Connection: {}", addr.to_string());

    let mut buffer = [0u8; 1024];
    loop {
        let len = stream.read(&mut buffer).await?; 

        if len > 0 {
            print!("{} => {}", addr.to_string(), String::from_utf8_lossy(&buffer));

            let users = users.lock().await;
            
            for mut user in &*users {
                // send everyone except itself
                if user.peer_addr()? != stream.peer_addr()? {
                    user.write(&buffer).await?;
                }
            }
        }
        else {
            println!("Disconnected: {}", addr.to_string());
            break;
        }
    };

    Ok(())
}

#[async_std::main]
async fn main() -> Result<()>{
    let listener = TcpListener::bind("127.0.0.1:14530").await?;
    let users = Vec::new();
    let arc_users = Arc::new(Mutex::new(users));
    
    loop {
        let users = arc_users.clone();
        let (stream, addr) = listener.accept().await?;

        let mut write_permission= users.lock().await;
        write_permission.push(stream.clone());
        drop(write_permission);
        
        task::spawn(on_connection(stream, addr, users));
    };
}