How to group to 2 clients to send messages

What i'm trying to do is group 2 clients and make them communicate with eachother. So if 2 clients are connected they would only be able to communicate with eachother and if a third client got connected it would not be able to communicate with the 2 other clients but it would create another group of 2 clients and so on... My code below currently broadcasts one message from one client to all clients but i would like it work like described above and have been having a difficult time finding a solution. Any help is appreciated.

public class ChatServer {
private static final int PORT = 9001;
private static HashSet<String> names = new HashSet<String>();
private static HashSet<PrintWriter> writers = new HashSet<PrintWriter>();
static int clientCounter = 0;
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 Handler(listener.accept()).start();
}
} finally {
listener.close();
}
}
private static class Handler extends Thread {
private String name;
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public Handler(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 (names) {
if (!names.contains(name)) {
names.add(name);
break;
}
}
}
out.println("NAMEACCEPTED");
clientCounter++;
if (clientCounter > 0 && clientCounter <= 2) {
writers.add(out);
while (true) {
String input = in.readLine();
if (input == null) {
return;
}
for (PrintWriter writer : writers) {
writer.println("MESSAGE " + name + ": " + input);
}
}
} else {
clientCounter = 1;
}
} catch (IOException e) {
System.out.println(e);
} finally {
if (name != null) {
names.remove(name);
}
if (out != null) {
writers.remove(out);
}
try {
socket.close();
} catch (IOException e) {
}
}
}
}

}

The easiest Solution i can think of is:

make a class that extends thread and takes two sockets as input

all this class does in run is to wait for anything being written to the first socket and sending it to the second socket

your main function simply waits for connections

when it get's a connection it accepts it and saves the socket (i call it socketA from now) but keeps waiting for a second connection (because you need two clients for your chat program)

once a second connection comes you accept it (this will be socketB)

it now creates two objects from your class from the beginning, one taking socketA as first, socketB as second argument, the other one taking socketB as first and socketA as second argument

the first instance takes care of sending messages from socketA to socketB, the second from socketB to socketA which let's the two chat

your main now just has to wait for the next connection and "restart" from the beginning

Here's one way to make it work. First you need to modify the loop that accepts connections, so that it keeps track of a "previously accepted socket". When a client connects, you check if there is previousSocket: if there isn't you store the current its socket as previousSocket. If there is one, you now have two clients that have connected, and they can communicate with each other:

Socket previousSocket = null;
while (true) {
Socket newSocket = listener.accept();
if (previousSocket == null) {
previousSocket = newSocket;
} else {
new Handler(previousSocket, newSocket).start();
new Handler(newSocket, previousSocket).start();
previousSocket = null;
}
}

The other change you will need is to add the concept of a "peer" to your Handler class. The peer is the socket that you use to communicate with the other client. Then you replace the for loop that sends messages to all clients with code that sends the message to the peer only:

peerOut.println("MESSAGE " + name + ": " + input);

Here's a more complete code sample for the modified Handler class to illustrate. I've omitted the name registration and error handling for brevity - you'll need to add it back.

private static class Handler extends Thread {
private String name;
private Socket socket;
private Socket peerSocket;
private BufferedReader in;
private PrintWriter out;
public Handler(Socket socket, Socket peerSocket) {
this.socket = socket;
this.peerSocket = peerSocket;
}
public void run() {
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
// name registration and error handling omitted for brevity
PrintWriter peerOut = new PrintWriter(peerSocket.getOutputStream(), true);
while (true) {
String input = in.readLine();
if (input == null) {
return;
}
// Replaces "for (PrintWriter writer : writers) { ... }"
peerOut.println("MESSAGE " + name + ": " + input);
}
}
}