1. Simulate the functioning of Lamport's Logical Clock in JAVA.
import java.util.*;
class Process {
private int id;
private int logicalClock;
public Process(int id) {
this.id = id;
this.logicalClock = 0;
}
public int getId() {
return id;
}
public int getLogicalClock() {
return logicalClock;
}
public void tick() {
logicalClock++;
}
public void receiveMessage(int senderClock) {
logicalClock = Math.max(logicalClock, senderClock) + 1;
}
@Override
public String toString() {
return "Process " + id + " (Clock: " + logicalClock + ")";
}
}
class Event {
private Process sender;
private Process receiver;
public Event(Process sender, Process receiver) {
this.sender = sender;
this.receiver = receiver;
}
public void execute() {
sender.tick();
int senderClock = sender.getLogicalClock();
receiver.receiveMessage(senderClock);
System.out.println(sender + " sent a message to " + receiver);
System.out.println("Updated " + receiver);
}
}
public class LamportLogicalClock {
public static void main(String[] args) {
Process p1 = new Process(1);
Process p2 = new Process(2);
Process p3 = new Process(3);
List<Event> events = new ArrayList<>();
events.add(new Event(p1, p2));
events.add(new Event(p2, p3));
events.add(new Event(p3, p1));
events.add(new Event(p2, p1));
events.add(new Event(p1, p3));
System.out.println("Initial state:");
System.out.println(p1);
System.out.println(p2);
System.out.println(p3);
System.out.println();
for (Event event : events) {
event.execute();
System.out.println();
}
System.out.println("Final state:");
System.out.println(p1);
System.out.println(p2);
System.out.println(p3);
}
}
// Run the simulation
LamportLogicalClock.main(null);
1. Simulate the Distributed Mutual Exclusion in JAVA.
import java.util.Random;
public class DistributedMutualExclusion {
private static final int NUM_PROCESSES = 5;
private static final int MAX_REQUESTS = 10;
private static Process[] processes;
private static int totalRequests = 0;
private static Random random = new Random();
static class Process {
int id;
int timestamp;
boolean requesting;
boolean inCS;
boolean[] deferReplies;
Process(int id) {
this.id = id;
this.timestamp = 0;
this.requesting = false;
this.inCS = false;
this.deferReplies = new boolean[NUM_PROCESSES];
public static void main(String[] args) {
initializeProcesses();
simulateDistributedMutualExclusion();
private static void initializeProcesses() {
processes = new Process[NUM_PROCESSES];
for (int i = 0; i < NUM_PROCESSES; i++) {
processes[i] = new Process(i);
private static void simulateDistributedMutualExclusion() {
while (totalRequests < MAX_REQUESTS) {
int processId = random.nextInt(NUM_PROCESSES);
if (!processes[processId].requesting && !processes[processId].inCS) {
requestCriticalSection(processId);
} else if (processes[processId].inCS) {
releaseCriticalSection(processId);
// Simulate message passing and handling
for (int i = 0; i < NUM_PROCESSES; i++) {
if (i != processId) {
handleRequest(processId, i);
handleReply(i, processId);
printSystemState();
private static void requestCriticalSection(int processId) {
processes[processId].requesting = true;
processes[processId].timestamp = totalRequests;
System.out.printf("Process %d is requesting critical section (TS: %d)%n", processId,
processes[processId].timestamp);
}
private static void releaseCriticalSection(int processId) {
processes[processId].inCS = false;
processes[processId].requesting = false;
System.out.printf("Process %d is releasing critical section%n", processId);
// Send deferred replies
for (int i = 0; i < NUM_PROCESSES; i++) {
if (processes[processId].deferReplies[i]) {
processes[processId].deferReplies[i] = false;
System.out.printf("Process %d sends deferred reply to Process %d%n", processId, i);
totalRequests++;
private static void handleRequest(int senderId, int receiverId) {
if (processes[receiverId].inCS ||
(processes[receiverId].requesting &&
processes[receiverId].timestamp < processes[senderId].timestamp)) {
processes[receiverId].deferReplies[senderId] = true;
System.out.printf("Process %d defers reply to Process %d%n", receiverId, senderId);
} else {
System.out.printf("Process %d sends reply to Process %d%n", receiverId, senderId);
private static void handleReply(int senderId, int receiverId) {
if (processes[receiverId].requesting) {
boolean canEnter = true;
for (int i = 0; i < NUM_PROCESSES; i++) {
if (i != receiverId && processes[receiverId].deferReplies[i]) {
canEnter = false;
break;
if (canEnter) {
processes[receiverId].inCS = true;
processes[receiverId].requesting = false;
System.out.printf("Process %d enters critical section%n", receiverId);
private static void printSystemState() {
System.out.println("\nSystem State:");
for (int i = 0; i < NUM_PROCESSES; i++) {
System.out.printf("Process %d: %s %s%n", i,
processes[i].requesting ? "Requesting" : "Not Requesting",
processes[i].inCS ? "In CS" : "Not In CS");
System.out.println();
}
2. Implement a Distributed Chat Server using TCP Sockets in JAVA
SERVER.JAVA
import java.io.*;
import java.net.*;
import java.util.*;
public class Server {
private static final int PORT = 5000;
private static HashSet<PrintWriter> writers = new HashSet<>();
public static void main(String[] args) throws Exception {
System.out.println("The chat server is running...");
ServerSocket listener = new ServerSocket(PORT);
try {
while (true) {
new ClientHandler(listener.accept()).start();
} finally {
listener.close();
private static class ClientHandler extends Thread {
private String name;
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public ClientHandler(Socket socket) {
this.socket = socket;
}
public void run() {
try {
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
out = new PrintWriter(socket.getOutputStream(), true);
while (true) {
out.println("SUBMITNAME");
name = in.readLine();
if (name == null) {
return;
synchronized (writers) {
if (!writers.contains(out)) {
out.println("NAMEACCEPTED");
writers.add(out);
break;
while (true) {
String input = in.readLine();
if (input == null) {
return;
for (PrintWriter writer : writers) {
writer.println("MESSAGE " + name + ": " + input);
}
} catch (IOException e) {
System.out.println(e);
} finally {
if (name != null) {
System.out.println(name + " is leaving");
if (out != null) {
writers.remove(out);
try {
socket.close();
} catch (IOException e) {
CLIENT.JAVA
import java.awt.event.*;
import java.io.*;
import java.net.*;
import javax.swing.*;
public class Client {
BufferedReader in;
PrintWriter out;
JFrame frame = new JFrame("Chatter");
JTextField textField = new JTextField(40);
JTextArea messageArea = new JTextArea(8, 40);
public Client() {
textField.setEditable(false);
messageArea.setEditable(false);
frame.getContentPane().add(textField, "North");
frame.getContentPane().add(new JScrollPane(messageArea), "Center");
frame.pack();
textField.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
out.println(textField.getText());
textField.setText("");
});
private String getServerAddress() {
return JOptionPane.showInputDialog(
frame,
"Enter IP Address of the Server:",
"Welcome to the Chatter",
JOptionPane.QUESTION_MESSAGE);
private String getName() {
return JOptionPane.showInputDialog(
frame,
"Choose a screen name:",
"Screen name selection",
JOptionPane.PLAIN_MESSAGE);
private void run() throws IOException {
String serverAddress = getServerAddress();
Socket socket = new Socket(serverAddress, 5000);
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
out = new PrintWriter(socket.getOutputStream(), true);
while (true) {
String line = in.readLine();
if (line.startsWith("SUBMITNAME")) {
out.println(getName());
} else if (line.startsWith("NAMEACCEPTED")) {
textField.setEditable(true);
} else if (line.startsWith("MESSAGE")) {
messageArea.append(line.substring(8) + "\n");
public static void main(String[] args) throws Exception {
Client client = new Client();
client.frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
client.frame.setVisible(true);
client.run();
}
3. Implement Java RMI" mechanism for accessing methods of
remote systems
CalculatorService.java (Remote Interface)
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface CalculatorService extends Remote {
int add(int a, int b) throws RemoteException;
int subtract(int a, int b) throws RemoteException;
int multiply(int a, int b) throws RemoteException;
int divide(int a, int b) throws RemoteException;
CalculatorServiceImpl.java (Remote Object Implementation)
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
public class CalculatorServiceImpl extends UnicastRemoteObject implements
CalculatorService {
public CalculatorServiceImpl() throws RemoteException {
super();
@Override
public int add(int a, int b) throws RemoteException {
return a + b;
}
@Override
public int subtract(int a, int b) throws RemoteException {
return a - b;
@Override
public int multiply(int a, int b) throws RemoteException {
return a * b;
@Override
public int divide(int a, int b) throws RemoteException {
if (b == 0) {
throw new RemoteException("Division by zero");
return a / b;
CalculatorServer.java (RMI Server)
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class CalculatorServer {
public static void main(String[] args) {
try {
// Create and export the remote object
CalculatorService calculator = new CalculatorServiceImpl();
// Create and start the RMI registry on port 1099
Registry registry = LocateRegistry.createRegistry(1099);
// Bind the remote object to the registry
registry.rebind("CalculatorService", calculator);
System.out.println("Calculator Server is running...");
} catch (Exception e) {
System.err.println("Server exception: " + e.toString());
e.printStackTrace();
CalculatorClient.java (RMI Client)
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class CalculatorServer {
public static void main(String[] args) {
try {
// Create and export the remote object
CalculatorService calculator = new CalculatorServiceImpl();
// Create and start the RMI registry on port 1099
Registry registry = LocateRegistry.createRegistry(1099);
// Bind the remote object to the registry
registry.rebind("CalculatorService", calculator);
System.out.println("Calculator Server is running...");
} catch (Exception e) {
System.err.println("Server exception: " + e.toString());
e.printStackTrace();
CalculatorService.java (Remote Interface)
```java project="JavaRMIExample" file="CalculatorService.java"
CalculatorServiceImpl.java (Remote Object Implementation)
java project="JavaRMIExample" file="CalculatorServiceImpl.java"
CalculatorServer.java (RMI Server)
java project="JavaRMIExample" file="CalculatorServer.java"
CalculatorClient.java (RMI Client)
java project="JavaRMIExample" file="CalculatorClient.java"
4. Simulate Balanced Sliding Window Protocol in JAVA.
import java.util.*;
public class BalancedSlidingWindowProtocol {
private static final int TOTAL_PACKETS = 20;
private static final int INITIAL_WINDOW_SIZE = 4;
private static final double PACKET_LOSS_PROBABILITY = 0.2;
private static final int TIMEOUT = 5;
private static class Sender {
int base;
int nextSeqNum;
int windowSize;
boolean[] acked;
Timer[] timers;
Sender() {
base = 0;
nextSeqNum = 0;
windowSize = INITIAL_WINDOW_SIZE;
acked = new boolean[TOTAL_PACKETS];
timers = new Timer[TOTAL_PACKETS];
void send(Receiver receiver) {
while (nextSeqNum < base + windowSize && nextSeqNum < TOTAL_PACKETS) {
if (Math.random() > PACKET_LOSS_PROBABILITY) {
System.out.println("Sender: Sending packet " + nextSeqNum);
receiver.receive(nextSeqNum);
} else {
System.out.println("Sender: Packet " + nextSeqNum + " lost");
}
startTimer(nextSeqNum);
nextSeqNum++;
void startTimer(int seqNum) {
timers[seqNum] = new Timer();
timers[seqNum].schedule(new TimerTask() {
@Override
public void run() {
handleTimeout(seqNum);
}, TIMEOUT * 1000);
void handleTimeout(int seqNum) {
System.out.println("Sender: Timeout for packet " + seqNum);
nextSeqNum = seqNum;
send(null); // Resend from the timed-out packet
void receiveAck(int ackNum) {
System.out.println("Sender: Received ACK for packet " + ackNum);
acked[ackNum] = true;
if (ackNum == base) {
while (base < TOTAL_PACKETS && acked[base]) {
if (timers[base] != null) {
timers[base].cancel();
}
base++;
adjustWindow(true);
void adjustWindow(boolean increase) {
if (increase && windowSize < TOTAL_PACKETS) {
windowSize++;
System.out.println("Sender: Increasing window size to " + windowSize);
} else if (!increase && windowSize > 1) {
windowSize--;
System.out.println("Sender: Decreasing window size to " + windowSize);
private static class Receiver {
int expectedSeqNum;
int windowSize;
Receiver() {
expectedSeqNum = 0;
windowSize = INITIAL_WINDOW_SIZE;
void receive(int seqNum) {
if (seqNum == expectedSeqNum) {
System.out.println("Receiver: Received packet " + seqNum);
sendAck(seqNum);
expectedSeqNum++;
adjustWindow(true);
} else if (seqNum > expectedSeqNum) {
System.out.println("Receiver: Received out-of-order packet " + seqNum);
sendAck(expectedSeqNum - 1);
adjustWindow(false);
} else {
System.out.println("Receiver: Received duplicate packet " + seqNum);
sendAck(seqNum);
void sendAck(int ackNum) {
System.out.println("Receiver: Sending ACK for packet " + ackNum);
// In a real implementation, this would send the ACK back to the sender
void adjustWindow(boolean increase) {
if (increase && windowSize < TOTAL_PACKETS) {
windowSize++;
System.out.println("Receiver: Increasing window size to " + windowSize);
} else if (!increase && windowSize > 1) {
windowSize--;
System.out.println("Receiver: Decreasing window size to " + windowSize);
public static void main(String[] args) {
Sender sender = new Sender();
Receiver receiver = new Receiver();
while (sender.base < TOTAL_PACKETS) {
sender.send(receiver);
// Simulate ACKs being received (with some delay and possible loss)
for (int i = sender.base; i < sender.nextSeqNum; i++) {
if (Math.random() > PACKET_LOSS_PROBABILITY) {
try {
Thread.sleep((int) (Math.random() * 1000)); // Random delay
} catch (InterruptedException e) {
e.printStackTrace();
sender.receiveAck(i);
try {
Thread.sleep(1000); // Wait a bit before next send
} catch (InterruptedException e) {
e.printStackTrace();
System.out.println("Transmission complete!");
}
5. Implement CORBA mechanism by using C++program at one end
and Java program on the other.
Define the IDL File:
// Filename: Hello.idl
module HelloApp {
interface Hello {
string say_hello();
};
};
C++ Side (Server):
// HelloServer.cpp
#include "Hello.hh" // Generated by the IDL compiler
#include <tao/ORB.h>
#include <ace/Log_Msg.h>
class HelloImpl : public virtual POA_HelloApp::Hello {
public:
HelloImpl() {}
virtual ~HelloImpl() {}
virtual char* say_hello() {
return CORBA::string_dup("Hello from C++ CORBA Server!");
}
};
int main(int argc, char* argv[]) {
try {
// Initialize the ORB
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
// Create an object servant
HelloImpl hello_impl;
// Obtain the root POA and activate the servant
CORBA::Object_var root_poa_object = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow(root_poa_object.in());
PortableServer::ServantBase_var owner_transfer = hello_impl._this();
// Run the ORB event loop
orb->run();
}
catch (const CORBA::Exception& ex) {
ex._tao_print_exception("Exception caught in C++ server:");
return 1;
}
return 0;
}
Java Side (Client):
// HelloClient.java
import HelloApp.*;
public class HelloClient {
public static void main(String[] args) {
try {
// Initialize the ORB
org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init(args, null);
// Get the object reference of the server
org.omg.CORBA.Object obj =
orb.string_to_object("corbaloc:iiop:localhost:12345/Hello");
// Narrow the object reference to the Hello interface
Hello hello = HelloHelper.narrow(obj);
// Call the method on the server
System.out.println(hello.say_hello());
} catch (Exception e) {
e.printStackTrace();
}
}
}
Run the Server and Client:
Run the C++ server:
Compile the C++ server code (HelloServer.cpp) and run it:
g++ -o HelloServer HelloServer.cpp -lTAO -lACE
./HelloServer
Run the Java client:
Compile the Java client code (HelloClient.java) and run it:
javac HelloClient.java
java HelloClient
