Scribd
Upload
31 views12 pages

Assignment 4

as

Uploaded by

Ram Chrestha
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
31 views12 pages

Assignment 4

as

Uploaded by

Ram Chrestha
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 12

Multithreaded Server: A server having more than one thread is known as

Multithreaded Server. When a client sends the request, a thread is generated


through which a user can communicate with the server. We need to generate
multiple threads to accept multiple requests from multiple clients at the same
time.

Advantages of Multithreaded Server:


 Quick and Efficient: Multithreaded server could respond efficiently and
quickly to the increasing client queries quickly.
 Waiting time for users decreases: In a single-threaded server, other users
had to wait until the running process gets completed but in multithreaded
servers, all users can get a response at a single time so no user has to wait for
other processes to finish.
 Threads are independent of each other: There is no relation between any
two threads. When a client is connected a new thread is generated every
time.
 The issue in one thread does not affect other threads: If any error occurs
in any of the threads then no other thread is disturbed, all other processes
keep running normally. In a single-threaded server, every other client had to
wait if any problem occurs in the thread.
Disadvantages of Multithreaded Server:
 Complicated Code: It is difficult to write the code of the multithreaded server.
These programs can not be created easily
 Debugging is difficult: Analyzing the main reason and origin of the error is
difficult.
Quick Overview
We create two java files, Client.java and Server.java. Client file contains only
one class Client (for creating a client). Server file has two
classes, Server(creates a server) and ClientHandler(handles clients using
multithreading).

Client-Side Program: A client can communicate with a server using this code.
This involves
1. Establish a Socket Connection
2. Communication
 Java

import java.io.*;

import java.net.*;

import java.util.*;
// Client class

class Client {

// driver code

public static void main(String[] args)

// establish a connection by providing 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);

out.flush();

// displaying server reply

System.out.println("Server replied "

+ in.readLine());

// closing the scanner object

sc.close();
}

catch (IOException e) {

e.printStackTrace();

Server-Side Program: When a new client is connected, and he sends the


message to the server.
1. Server class: The steps involved on the server side are similar to the
article Socket Programming in Java with a slight change to create the thread
object after obtaining the streams and port number.
 Establishing the Connection: Server socket object is initialized and inside a
while loop a socket object continuously accepts an incoming connection.
 Obtaining the Streams: The inputstream object and outputstream object is
extracted from the current requests’ socket object.
 Creating a handler object: After obtaining the streams and port number, a
new clientHandler object (the above class) is created with these parameters.
 Invoking the start() method: The start() method is invoked on this newly
created thread object.
2. ClientHandler class: As we will be using separate threads for each request,
let’s understand the working and implementation of the ClientHandler class
implementing Runnable. An object of this class acts as a Runnable target for a
new thread.
 First, this class implements Runnable interface so that it can be passed as
a Runnable target while creating a new Thread.
 Secondly, the constructor of this class takes a parameter, which can uniquely
identify any incoming request, i.e. a Socket.
 Inside the run() method of this class, it reads the client’s message and
replies.
 Java

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 getting

// client request

while (true) {

// socket object to receive incoming client

// requests
Socket client = server.accept();

// Displaying that new client is connected

// to server

System.out.println("New client connected"

+ client.getInetAddress()

.getHostAddress());

// create a new thread object

ClientHandler clientSock

= new ClientHandler(client);

// This thread will handle the client

// separately

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;

// Constructor

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 received 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();

clientSocket.close();

}
}

catch (IOException e) {

e.printStackTrace();

Steps:
 Compile both Client and Server programs.
 Run the server first and then the Client.

Constructing Server Sockets

Look for local ports

import java.io.*;

import java.net.*;

public class serversocket {

public static void main(String[] args) {

for (int port = 1; port <= 65535; port++) {

try {

// the next line will fail and drop into the catch block if

// there is already a server running on the port

ServerSocket server = new ServerSocket(port);

} catch (IOException ex) {


System.out.println("There is a server on port " + port + ".");

Getting Information About a Server Socket

Selecting random port

import java.io.*;

import java.net.*;

public class random {

public static void main(String[] args) {

try {

ServerSocket server = new ServerSocket(0);

System.out.println("This server runs on port "

+ server.getLocalPort());

} catch (IOException ex) {

System.err.println(ex);

You might also like