This is first multithreading server

Author: MarcusChau

Client.java

@@ -0,0 +1,50 @@
+/*
+ * Client contains the class to create a client
+ */
+import java.io.*;
+import java.net.*;
+import java.util.*;
+
+
+// Client Class
+public class Client {
+
+    //drive code
+    public static void main(String[] args) {
+        // established a connection by provided host and port number
+        try( Socket socket = new Socket("localhost", 1234)) {
+
+            // writing to server
+            PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
+
+            // reading from server
+            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
+
+            // object of scanner class
+            Scanner sc = new Scanner(System.in);
+            String line = null;
+
+            while(!"exit".equalsIgnoreCase(line)) {
+
+                // reading from user
+                line = sc.nextLine();
+
+                // sending the user input to server
+                out.println(line);
+                // clearing stream
+                out.flush();
+
+                // displaying server reply
+                System.out.println("Server replied " + in.readLine());
+            }
+
+            // closing the scanner object
+            sc.close();
+
+        }
+        catch (IOException e){
+            e.printStackTrace();
+        }
+    }
+
+}

Server.java

@@ -0,0 +1,123 @@
+/*
+ * Has 2 classes one class:
+ * Server to create a Server
+ * CLientHandler ot handle clients using multithreading
+ * 
+ * Life Cycle of multithreads:
+ * New 
+ *  - New Thread created, is in new state, the code has not been run yet
+ * Active
+ *  -(New thread created when invokes start(), it moves from new to active state)
+ *  -Runnable: Ready to run and is moved to runnable state, ready to run at anytime
+ *  -Running: Thread gets CPU, moves from runnable to running state. (Generally from runnable to running and again back to runnable)
+ * Blocked / Writing
+ *  - Whenever a thread is inactive for a span of time(not permanently) then the thread is either in blocked or waiting state
+ * Timed Waiting
+ *  -Sometimes waiting for leads to starvation, For example, a thread (its name is A) has entered the critical section of a code and is not willing to leave that critical section. In such a scenario, another thread (its name is B) has to wait forever, which leads to starvation. To avoid such scenario, a timed waiting state is given to thread B. Thus, thread lies in the waiting state for a specific span of time, and not forever. A real example of timed waiting is when we invoke the sleep() method on a specific thread. The sleep() method puts the thread in the timed wait state. After the time runs out, the thread wakes up and start its execution from when it has left earlier.
+ *  -sleep() normally used for timed waiting
+ * Terminated
+ *  - Multiple ways that a thread can terminate
+ *      - When a thread finishes its job, it exits normally
+ *      - Abnormal Termination:
+ *          - Occurs when some unusual events such as unhandled exception or segmentation fault
+ */
+import java.io.*;
+import java.net.*;
+
+
+// Server class
+class Server {
+    public static void main(String[] args) {
+        ServerSocket server = null;
+
+        try {
+
+            // server is listening on port "1234"
+            server = new ServerSocket(1234);
+            server.setReuseAddress(true);
+
+
+            // running infinite loop for geting client request
+            while(true) {
+
+                // returns new socket
+                Socket client = server.accept();
+                // returns remote IP address to which the socket is connected or returns null is the socket is not connected
+                InetAddress addy = client.getInetAddress();
+                // returns raw IP address in a string format
+                String remoteIp = addy.getHostAddress();
+
+
+                // Displaying that new client is connected to server
+                System.out.println("New client connected" + addy + remoteIp);
+
+                // create a new thread object
+                ClientHandler clientSock = new ClientHandler(client);
+
+                // This thread will handle the client seperately 
+                new Thread(clientSock).start();
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        finally {
+            if (server != null) {
+                try {
+                    server.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+
+    // ClientHandler class
+    private static class ClientHandler implements Runnable {
+
+        private final Socket clientSocket;
+
+        // Construtor
+        public ClientHandler(Socket socket) {
+            this.clientSocket = socket;
+        }
+
+        public void run() {
+            PrintWriter out = null;
+            BufferedReader in = null;
+
+            try{
+
+                // get the outputstream of client
+                out = new PrintWriter(clientSocket.getOutputStream(), true);
+
+                // get the inputStream of client
+                in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
+
+                String line;
+                while ((line = in.readLine()) != null) {
+
+                    // Writing the recieved message from client
+                    System.out.printf(" Sent from the client: %s\n", line);
+                    out.println(line);
+                }
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            finally {
+                try {
+                    if (out != null) {
+                        out.close();
+                    }
+                    if (in != null) {
+                        in.close();
+                    }
+                }
+                catch (IOException e) {
+                    e.printStackTrace();
+                } 
+            }
+        }
+
+    }
+    
+}