thread3.rs

Chapter08/thread3.rs

@@ -1,36 +1,42 @@
-extern crate nix;
-use nix::unistd::{fork,ForkResult};
 use std::{thread,time};
 use std::process;
+extern crate thread_id;
 use std::io::prelude::*;
-use std::net::TcpListener;
+use std::net::{TcpListener,TcpStream};
+use std::sync::{Arc,Mutex};
 
-fn serve(listener: TcpListener) -> ! {
+fn serve(incoming: Arc<Mutex<Vec<TcpStream>>>) {
-   for stream in listener.incoming() {
+   let t = time::Duration::from_millis(10);
-      let mut buffer = [0; 2048];
+   loop {
-      let mut tcp = stream.unwrap();
+      {
-      tcp.read(&mut buffer).expect("tcp read failed");
+         let mut incoming = incoming.lock().unwrap();
-      let response = format!("respond from #{}\n", process::id());
+         for stream in incoming.iter() {
-      tcp.write(response.as_bytes()).expect("tcp write failed");
+            let mut buffer = [0; 2048];
+            let mut tcp = stream;
+            tcp.read(&mut buffer).expect("tcp read failed");
+            let response = format!("respond from #{}:{}\n", process::id(), thread_id::get());
+            tcp.write(response.as_bytes()).expect("tcp write failed");
+         }
+         incoming.clear();
+      }
+      thread::sleep(t);
    }
-   panic!("unreachable");
 }
 
 fn main() {
    let listener = TcpListener::bind("127.0.0.1:8888").unwrap();
-   let mut children = Vec::new();
+   let incoming = Vec::new();
+   let incoming = Arc::new(Mutex::new(incoming));
 
    for _ in 0..3 {
-      match fork().expect("fork failed") {
+      let incoming = Arc::clone(&incoming);
-         ForkResult::Parent{ child: pid } => { children.push(pid); }
+      thread::spawn(move || {
-         ForkResult::Child => {
+         serve(incoming);
-            serve(listener)
+      });
-         }
-      }
    }
 
-   let t = time::Duration::from_millis(1000);
+   for stream in listener.incoming() {
-   loop {
+      let mut incoming = incoming.lock().unwrap();
-      thread::sleep(t);
+      (*incoming).push(stream.unwrap());
    }
 }