thread pool

src/bin/server.rs

@@ -1,31 +1,53 @@
 use std::{
-    io::{prelude::*, BufReader},
+    io::{prelude::*, BufReader, Lines},
     net::{TcpListener, TcpStream},
 };
-use std::io::Lines;
+use std::thread::available_parallelism;
+use crate::thread_pool::ThreadPool;
+
+mod thread_pool;
+
 
 fn main() {
+    // start server on localhost (for remote access use: 0.0.0.0)
     let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
+    
+    // create thread pool (size = no. of cpu cores)
+    let pool = ThreadPool::new(available_parallelism().unwrap().get());
 
+    // handling function for incoming requests
     for stream in listener.incoming() {
         let stream = stream.unwrap();
 
-        handle_connection(stream);
+        // pass request to thread pool
+        pool.execute(|| {
+            handle_connection(stream);
+        });
     }
+    println!("Shutting down.");
 }
 
+
 fn handle_connection(mut stream: TcpStream) {
+    // clone TcpStream for simultaneous receiving and sending
     let mut stream2: TcpStream = stream.try_clone().unwrap();
+
+    // initialize reading buffer (for better performance!)
     let buf_reader: BufReader<&mut TcpStream> = BufReader::new(&mut stream);
+    // request: read received text line by line (continuous until connection closed)
     let request: Lines<BufReader<&mut TcpStream>> = buf_reader.lines();
 
     println!("Request: {:#?}", request);
 
+    // processing function for every text line received by request (terminates when conn closed)
     for elem in request
     {
+        // store received line in variable s
         let s = elem.unwrap();
         println!("{:?}", s);
-        stream2.write(s.as_bytes()).unwrap();
+
+        // send received line back to sender (append LF)
+        stream2.write_all(s.as_bytes()).unwrap();
         stream2.write_all(b"\n").unwrap();
     }
 }