//被动连接端
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聊天的核心部分,剩下的也会用心设计功能,用脚写代码的(误