Rust 小结1 端到端聊天

//被动连接端
use std::io::{ErrorKind, Read, Write};
// use std::cmp::max;
use std::net::{TcpListener, TcpStream};
use std::{net, thread};
use std::borrow::BorrowMut;
use std::io::stdin;
use std::rc::Rc;
use std::sync::{Arc, Mutex};
use std::thread::Thread;
use std::time::Duration;
use std::io;
use std::os;
// 这个相当于接收端，可以这么说
fn listen_thread(listen_mux: Arc<Mutex<TcpStream>>) {
        loop{
            // 作用域在loop里面，第二次循环应该会自动解锁，，谁知道呢
            {

                let mut listen_lock = listen_mux.lock().unwrap();
                let mut p = [0; 64];
                match  (*listen_lock).read(&mut p) {
                    Ok(_) => {}
                    Err(e) => {
                        // 连接终端回收线程
                        if e.kind() == ErrorKind::ConnectionReset{
                            return ()
                        }
                    }
                }
                if p == [0; 64] {
                    continue
                }
                let mut s = String::from("");
                for h in p {
                    if h == 0 {
                        break;
                    }
                    s += &(String::from(h as char))
                }
                println!("Read Data: {}", s);
            }

        }

}
pub fn sender_thread(sender_: Arc<Mutex<TcpStream>>){
    loop{
        let mut a = String::from("");
        io::stdin().read_line(&mut a).expect("Can't read for some_reason");
        {
            let mut sender_lock = sender_.lock().unwrap();
            // 连接中断回收线程
            match (*sender_lock).write(a.as_bytes()) {
                Ok(_) => {}
                Err(_) => {println!("This is a new connection, Please resend your information"); return ();}
            }
            println!("Send data");
        }
    }
}
fn main() {
    let mut listener = TcpListener::bind("127.0.0.1:7878").unwrap();
    thread::sleep(Duration::from_secs(2));
    let mut p = 0;
    let mut q = 0;
    // 理论上支持多开，毕竟是多线程。实际上最好单开，不然你的Input并不一定保证发送给了需要的send线程
    for stream in listener.incoming(){
        let mut stream = stream.unwrap();
        stream.set_nonblocking(true);
        let mut m = Arc::new(Mutex::new(stream));
        let mut n =Arc::clone(&m);
        let mut p = thread::spawn(move || {sender_thread(m)} );
        let mut q = thread::spawn(move || {listen_thread(n)} );
        println!("123");
    }
}

# 发送端
import socket
from multiprocessing import Process, Queue


class send_to_7878(Process):
    def __init__(self, socket, queue):
        super().__init__()
        # 创建socket
        self.socket = socket
        self.queue = queue

    def send_message(self, message):
        self.socket.send(message.encode('ascii'))
        # print('发送成功')
        
    def _closed(self):
        return super().close()

    def run(self):
        while 1:
            p = self.queue.get()
            self.send_message(p)


class listen_self_3705(Process):
    def __init__(self, socket, listen_queue):
        super().__init__()
        # 创建socket
        self.socket = socket

    def listen(self):
        listen__ = self.socket.recv(1024)
        listen__ = listen__.decode('ascii').replace('\n', '')
        print(listen__)

    # def close(self):
    #     self.sender_server.close()
    def run(self):
        while 1:
            self.listen()

    def _closed(self):
        return super().close()
    
if __name__ == '__main__':
    s2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s2.connect(('127.0.0.1', 7878))
    send_queue = Queue(50)
    listen_queue = Queue(50)
    listen_ = listen_self_3705(s2, listen_queue)
    listen_.start()
    send_ = send_to_7878(s2, send_queue)
    send_.start()
    while 1:
        time.sleep(1)
        h = input()
        send_queue.put(h)

这玩应算一个不完全体，毕竟IP 和端口都定死了。中间肯定还需要server端并添加上用户机制的（在写了再写了）
不过在写这个服务的过程中，虽然只写了单端的Rust, 不过多线程和Arc的所有权归属确实是更深一步的了解了。算是有所收获的。以上代码是整个p2p聊天的核心部分，剩下的也会用心设计功能，用脚写代码的（误