DOCUMENTATION ON

CONCURRENT CHAT
SUBMITTED IN PARTIAL FULFILLMENT OF
THE REQUIREMENTS TO AWARD

THE DEGREE OF

BACHELOR OF ARTIFICIAL INTELLIGENCE AND MACHINE LEARNING

DESIGNED AND DEVELOPED BY

R. Ravikumar(22241A66B5)
P. Harshavardhan Reddy(22241A66B1)
V. Nikhil (22241A66C5)
UNDER THE GUIDANCE OF:

Ms. K. Kalpana & Mr. VSRK Raju

Asst. professor

DEPARTMENT OF

ARTIFICIAL INTELLIGENCE AND MACHINE LEARNING

GOKARAJU RANGARAJU INSTITUTE OF ENGINEERING AND

TECHNOLOGY

(Bachupally, Hyderabad,500090

Faculty Sign: Hod Sign:

 INDEX
S.N Table of Contents Page Number
o

1 Introduction 3

● Problem Statement
● Goal of the Project

2 Concurrent Chat 3

● Description
● Why Java?

3 Set up Environment 7

 VS code installation
● JDK installation

4 Concepts of OS in Concurrent chat 8

● Multithreading
● Concurrency and Synchronization

5 Implementation 12

 Main code(server code)

 Client code

6 Results 14

7 Limitations 15

 Limited Dynamic Functionality

 Security concerns

8 Conclusion 16

● Summary of the Project

1. Introduction
Problem Statement
Develop a simple and effective chat application that leverages multithreading to
handle concurrent read and write operations, ensuring a responsive and real-
time chat experience.
Goal of the Project
Design and implement a client-server chat application “Concurrent Chat”,
which supports real-time communication between a server and multiple clients
using multithreading to handle simultaneous message reading and writing
operations.

2. Concurrent Chat
Description
Concurrent Chat is a robust client-server chat application designed to facilitate
real-time communication between multiple clients and a server. Utilizing Java's
multithreading capabilities, the application ensures seamless and efficient
message exchange, providing a responsive and interactive chat experience.
Concurrent Chat is built to handle multiple simultaneous connections, enabling
users to connect to a central server and communicate in real-time without any
latency issues. This project demonstrates the effective use of threading to
manage concurrent operations, offering a reliable platform for real-time
messaging.
Features
 Real-Time Communication:
Description: Concurrent Chat enables real-time message exchange between
clients and the server, ensuring that messages are delivered instantly without
noticeable delay.
Benefit: This feature provides a smooth and responsive user experience,
crucial for effective real-time communication.
 Concurrent Client Handling:
Description: The server is capable of handling multiple client connections
simultaneously using multithreading. Each client runs in its own thread,
allowing independent and parallel message processing.
Benefit: This ensures scalability and reliability, allowing the chat application
to support multiple users at the same time without performance degradation.
 Graceful Disconnection:
Description: Both the server and clients can handle disconnections
gracefully. When a client sends an "exit" command, the connection is closed
cleanly, and resources are released appropriately.
Benefit: This feature prevents resource leaks and ensures that the system
remains stable and efficient over time.
 Thread-Safe Operations:
Description: The application uses thread-safe mechanisms to manage the
concurrent reading and writing of messages. Proper synchronization ensures
that messages are processed correctly without any data corruption or race
conditions.
Benefit: This ensures the reliability and integrity of message exchange,
making the application robust and trustworthy.
Why Java?
Java is a versatile, powerful, and widely-used programming language that offers
several compelling advantages for developing a robust and efficient client-
server chat application like Concurrent Chat. Here are key reasons why Java is
the ideal choice for this project:
 Platform Independence:
Description: Java is a platform-independent language, thanks to its "write
once, run anywhere" (WORA) capability. Java applications are compiled
into bytecode that can run on any device equipped with a Java Virtual
Machine (JVM).
Benefit: This ensures that the Concurrent Chat application can be deployed
across various operating systems without requiring any modifications,
making it highly portable and flexible.
 Multithreading Support:
Description: Java has built-in support for multithreading, providing a rich set
of APIs for creating and managing threads. It allows for concurrent
execution of tasks, which is essential for handling multiple clients
simultaneously in a chat application.
Benefit: The native multithreading capabilities of Java make it easier to
develop a responsive and efficient chat server that can handle multiple client
connections without performance bottlenecks.
 Robust Standard Libraries:
Description: Java comes with an extensive standard library that provides a
wide range of pre-built classes and functions for networking, I/O operations,
data structures, and more.
Benefit: These libraries simplify the development process by providing
ready-to-use components for socket programming, input/output stream
handling, and other functionalities required in a chat application.
 Security Features:
Description: Java provides a robust security model, including features like
bytecode verification, secure class loading, and a security manager that
defines access policies.
Benefit: These security features help in building secure client-server
applications, protecting the chat system from various vulnerabilities and
unauthorized access.
 Object-Oriented Programming:
Description: Java is a purely object-oriented programming language,
promoting concepts like inheritance, encapsulation, and polymorphism. This
approach helps in organizing code into reusable and modular components.
Benefit: The object-oriented nature of Java enhances code maintainability
and scalability, allowing developers to build a structured and extendable chat
application.
 Community and Ecosystem:
Description: Java has a large and active community of developers, extensive
documentation, and a vast ecosystem of third-party libraries and
frameworks.
Benefit: The strong community support and availability of resources make it
easier to find solutions, seek help, and integrate additional functionalities
into the ConcurrentChat application.
 Performance:
Description: Java's performance has significantly improved over the years
with the development of Just-In-Time (JIT) compilers and various
optimizations in the JVM.
 Benefit: These performance enhancements ensure that Java applications run
efficiently, providing a smooth and responsive experience for real-time chat
operations.
3. Set Up Environment
1.Install Java Development Kit (JDK):
Download the JDK from Oracle JDK or OpenJDK.
Follow the installation instructions for your operating system.
Set the JAVA_HOME environment variable:
Windows: Add JAVA_HOME with the JDK installation path and add
%JAVA_HOME%\bin to the Path.
Mac/Linux: Add export JAVA_HOME=/path/to/your/jdk and export
PATH=$JAVA_HOME/bin:$PATH to your shell configuration file
(.bashrc, .zshrc, etc.), then run source to apply changes.
2.Install Visual Studio Code:
Download and install VS Code from the official website.
3.Install Java Extensions in VS Code:
Open VS Code and go to the Extensions marketplace.
Install the "Extension Pack for Java" to enable Java support, including
debugging, linting, and project management features.
4.Open Your Project in VS Code:
Open the Concurrent Chat project folder in VS Code.

4. Concept Operating Systems in Concurrent chat

1.Multithreading:
Description: Multithreading is the ability of an operating system to
execute multiple threads concurrently. Each thread can perform a
different task, such as reading from or writing to a network socket,
without waiting for the other to complete.
Usage in Concurrent Chat: The server and client applications use
multithreading to handle simultaneous read and write operations. The
server creates a new thread for each client connection, allowing multiple
clients to connect and communicate with the server concurrently. This
ensures that the server remains responsive and can handle multiple clients
at the same time.
 Benefit: This approach maximizes the utilization of CPU resources and
improves the responsiveness and performance of the chat application,
making real-time communication seamless.

2. Concurrency and Synchronization:

Description: Concurrency refers to the ability of the operating system to

execute multiple operations simultaneously. Synchronization mechanisms
are used to control the access of multiple threads to shared resources,
preventing data corruption and ensuring thread safety.
Usage in ConcurrentChat: The application leverages concurrency to
manage multiple clients and handle their messages simultaneously.
Synchronization ensures that messages are correctly processed without
interference, especially when multiple threads try to read from or write to
shared resources like the network sockets or message buffers.
Benefit: Proper synchronization ensures the integrity and consistency of
the chat messages, preventing issues like race conditions and deadlocks,
thereby maintaining a stable and reliable communication system.

5. Implementation
To implement the ConcurrentChat application, we use Java's networking
and multithreading capabilities to create a client-server chat system.
Below is a concise overview of the key components:
Main Code
1.Server Setup:

Create a ServerSocket on a specified port (e.g., 7788).

Accept client connections and create a new thread for each client.

2.Reading Messages:

Use a separate thread to continuously read messages from each client.

Close the connection if the client sends an "exit" message.

3.Writing Messages:

Use another thread to read messages from the server console and send
them to the client.
 Close the connection if the server sends an "exit" message.
Client Code
1.Client Setup:
Connect to the server using the server's IP address and port.
Initialize input and output streams for communication.
2.Reading Messages:
Use a separate thread to continuously read messages from the server.
Close the connection if the server sends an "exit" message.
3.Writing Messages:
Use another thread to read messages from the client console and send
them to the server.
Close the connection if the client sends an "exit" message.
Source code:
Main.java
import java.io.BufferedReader;

import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.*;

public class Main {

ServerSocket serverSocket;
Socket socket;

BufferedReader br;
PrintWriter out;
public Main()
{
try{
serverSocket = new ServerSocket(7788);
System.out.println("Connection established");
socket = serverSocket.accept();
br = new BufferedReader(new
InputStreamReader(socket.getInputStream()));
 out = new PrintWriter(socket.getOutputStream());

startReading();
startWriting();
}
catch(Exception e)
{
e.printStackTrace();
}
}
public void startReading(){

Runnable t1 = () ->{
System.out.println("READER");
try
{
while (true) {

String msg = br.readLine();

if(msg.equals("exit"))
{
System.out.println("CLIENT EXITED");
socket.close();
break;
}
System.out.println("CLIENT : " +msg);
}
}
catch(Exception e)
{
System.out.println("CLOSED");
}
};

new Thread(t1).start();
}
private void startWriting(){

Runnable t2 = () ->{
System.out.println("WRITER");
try{
while (!socket.isClosed()) {
 BufferedReader br2 = new BufferedReader(new
InputStreamReader(System.in));
String content = br2.readLine();
out.println(content);
out.flush();
if(content.equals("exit"))
{
socket.close();
break;
}
}
}
catch(Exception e)
{
System.out.println("CLOSED");
}
};

new Thread(t2).start();
}
public static void main(String args[])
{
System.out.println("SERVER");
new Main();
}
}

Client.java
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

public class Client {

Socket socket;
BufferedReader br;
PrintWriter out;
 public Client()
{
try{

System.out.println("Sending request to server");

socket = new Socket("127.0.0.1",7788);
System.out.println("Connection established");

br = new BufferedReader(new
InputStreamReader(socket.getInputStream()));
out = new PrintWriter(socket.getOutputStream());

startReading();
startWriting();
}
catch(Exception e)
{
e.printStackTrace();
}
}
public void startReading(){

Runnable t1 = () ->{
System.out.println("READER");
try{
while (true) {

String msg = br.readLine();

if(msg.equals("exit"))
{
System.out.println("Server EXITED");
socket.close();
break;
}
System.out.println("Server : " + msg);
}
}
catch(Exception e)
{
System.out.println("CLOSED");
}
};
 new Thread(t1).start();
}
private void startWriting(){

Runnable t2 = () ->{
System.out.println("WRITER");
try{

while (!socket.isClosed()) {

BufferedReader br2 = new BufferedReader(new

InputStreamReader(System.in));
String content = br2.readLine();
out.println(content);
out.flush();
if(content.equals("exit"))
{
socket.close();
break;
}
}
}
catch(Exception e)
{
System.out.println("CLOSED");
}
};

new Thread(t2).start();
}
public static void main(String args[])
{
System.out.println("CLIENT");
new Client();
}
}
6. Results
7. Limitations
1.Scalability Issues:
Description: The current implementation creates a new thread for each client
connection. As the number of clients increases, the number of threads also
increases, potentially leading to high memory usage and context-switching
overhead.
Impact: This approach may not scale well for a large number of concurrent
users, limiting the application's ability to handle heavy traffic efficiently.
2.Single Server Constraint:
Description: The server code is designed to run on a single machine, which can
become a bottleneck when handling numerous client connections.
Impact: Without load balancing or distributed server architecture, the server
may experience performance degradation under heavy load, affecting the
responsiveness and reliability of the chat service.
3.Lack of Fault Tolerance:
Description: The current design does not include mechanisms for fault tolerance
or automatic recovery in case of server failures.
Impact: If the server crashes or experiences network issues, all connected clients
will be disconnected, and the chat service will be interrupted until the server is
manually restarted.
4.Basic Security:
Description: The application does not implement advanced security measures
such as encryption, authentication, or secure communication protocols.
Impact: Data transmitted between clients and the server is vulnerable to
interception and unauthorized access, posing significant security risks.
5.Resource Management:
Description: The server does not manage resources such as socket connections
and threads efficiently. For example, if a client abruptly disconnects, the server
might not release associated resources promptly.
Impact: Inefficient resource management can lead to memory leaks and reduced
performance over time, potentially causing the server to run out of resources
and crash.
8 . Summary of the Project
The Concurrent Chat application leverages key operating system concepts such as
multithreading, socket programming, and concurrency with synchronization to
facilitate real-time communication between multiple clients and a server. By
employing multithreading, the application can handle multiple client connections
simultaneously, ensuring responsiveness and efficient CPU utilization. Socket
programming enables reliable data transmission over the network, forming the
backbone of the client-server communication. Additionally, synchronization
mechanisms maintain data integrity and thread safety during concurrent read and write
operations. However, the current implementation faces limitations in scalability, fault
tolerance, security, and resource management, highlighting areas for improvement to
create a more robust and scalable chat system.