Task One:

$1.$ Create a new Java Project called $$MultiThreadServer$$

$2.$ In the new project, create a package called $$server$.$

$3.$ In the server package, create a new class called $$MultiThreadServer$.$

$4.$ In the $$MultiThreadServer$$ class create three $(3)$ attributes:

$-$ ServerSocket serverSocket

$-$ Socket connectionSocket; and

$-$ int clientCount $($to keep track of how many clients has connected and

by extension the number of threads created$).$

$5.$ In a parameterless constructor in the $$MultiThreadServer$$ class, instantiate the

relevant attributes. The Server should be listening on Port $8000.$

$6.$ Place a print statement which Declares that the server has started, along with the

Date and time the server started.

$7.$ In the constructor, Create an infinite loop.

$8.$ Inside the infinite loop, listen for and accept any client request to connect.

$9.$ Place a print statement in the loop which Declares that the server is starting a

thread for a client, along with the client count and Date and time the thread

started.

Task Two:

$10.$Inside the $$MultiThreadServer$$ class, create an inner class called $$ClientHandler$$

which implements the Runnable interface.

$11.$ In the ClientHandler class, implement all abstract methods.

$12.$ In the ClientHandler class, create three $(3)$ attributes: one of type Socket; another

of type DataOutp.utStream; and the third of type DataInputStream.

$13.$ Create a constructor that accepts a Socket object as its argument. Inside the

constructor of the inner class, instantiate the attributes appropriately.

$14.$ Handle any exceptions that may occur.

$15.$ Inside the run method, create a loop that will be used to continuously serve a

client.

$16.$ Inside the loop create two variables of type double: one to store a radius value

and the other to store the area of a circle.

$17.$ Using the DataInputStream Object$$s readDouble method, accept a radius from a

client and assign the value to the variable you created above to store the radius.

$18.$ Using the radius calculate the area of a circle and assign the value to the variable

you created above to store a circle$$s area.

$19.$ Using the DataOutpuStream object$$s writeDouble method, send the area back to

the client.

$20.$Display $($in the ClientHandler$)$ the radius received from the client and the

calculated area.

$21.$ Handle all exceptions appropriately.

Task Three:

$22.$Inside the constructor inside the $$MultiThreadServer$$ class, create an instance of

the ClientHandler class, passing it the Socket object as its argument.

$23.$Create a new Thread Object, passing the ClientHandler object cast to a Runnable,

i$.$e$.,($Runnable$)$ obj, as its argument.

$24.$Start the thread by calling the start method on the thread object, i$.$e$.,$

threadObj.start$()$;

$25.$Increment the client count, i$.$e$.,$ the thread count variable.

Task Four:

$26.$Start the server and ensure all is well.

Task Five:

$27.$ Using your knowledge from prior lessons, create a new Project Client application

that will connect to this $$MultiThreadServer$.$ When successfully connected, the

client is to:

$-$ send a double value representing a circle$$s radius.

$-$ receive a double value representing the area of a circle, whose radius it had

sent to the server.

$28.$Write code to display the radius sent to the server and the area of the circle,

returned from the server.

Task Six:

$29.$Start the client application and test the program.