Trying to have multiple threads to allow for multiple clients, but

something is going wrong with the blocking when server Socket calls
.accept()

Author: samshuster

bin/.gitignore

@@ -2,3 +2,5 @@
 /ChatClient.class
 /ChatServer.class
 /JavaChat.class
+/ChatServerHelper.class
+/Connection.class

src/ChatClient.java

@@ -4,13 +4,15 @@
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
+import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.net.Socket;
 
 public class ChatClient {
 	private Socket mySocket = null;
 	private BufferedReader inputStream = null;
 	private DataOutputStream outputStream = null;
+	private BufferedReader otherInputStream = null;
 	private String endLine = ".bye";
 
 	public ChatClient(String serverName, int portNum){
@@ -34,6 +36,10 @@ private void haveChat(){
 				line = this.inputStream.readLine();
 				outputStream.writeUTF(line);
 				outputStream.flush();
+				String inline = otherInputStream.readLine();
+				if(!inline.equals("")){
+					System.out.println(inline);
+				}
 			} catch(IOException ioe){
 				System.out.println("Error: " + ioe.getMessage());
 			}
@@ -43,6 +49,8 @@ private void haveChat(){
 	private void start() throws IOException{
 		inputStream = new BufferedReader(new InputStreamReader(System.in));
 		outputStream = new DataOutputStream(this.mySocket.getOutputStream());
+		otherInputStream = new BufferedReader(
+				new InputStreamReader(this.mySocket.getInputStream()));
 	}
 
 	private void stop(){

src/ChatServer.java

@@ -1,50 +1,44 @@
 
 import java.io.BufferedInputStream;
 import java.io.DataInputStream;
+import java.io.DataOutputStream;
 import java.io.IOException;
+import java.io.OutputStream;
 import java.net.ServerSocket;
 import java.net.Socket;
+import java.util.ArrayList;
 import java.util.List;
 
 public class ChatServer implements Runnable {
 	private ServerSocket service = null;
-	private Socket socket = null;
-	private DataInputStream streamIn = null;
+	private ChatServerHelper helper = null;
 	private Thread thread = null;
 
 	public ChatServer(int portNum) {
 		try {
 			System.out.println("Creating a Chat Server on portNum: " + portNum);
 			service = new ServerSocket(portNum);
+			service.setSoTimeout(1000);
 			System.out.println("Chat Server Started");
 			System.out.println("Waiting for a client");
 			System.out.println(service.getInetAddress());
 			System.out.println("Success!");
+			helper = new ChatServerHelper(service);
 			start();
 		} catch (IOException e) {
 			System.out.println(e);
 		}
 	}
-
+	
 	private void start() {
 		if (thread == null) {
 			thread = new Thread(this);
 			thread.start();
 		}
 	}
-	
-	private void open() throws IOException {
-		this.streamIn = new DataInputStream(new BufferedInputStream(
-				this.socket.getInputStream()));
-	}
 
 	private void close() throws IOException {
-		if (streamIn != null) {
-			streamIn.close();
-		}
-		if (socket != null) {
-			socket.close();
-		}
+		helper.close();
 		if (service != null) {
 			service.close();
 		}
@@ -61,16 +55,47 @@ private void close() throws IOException {
 	public void run() {
 		// TODO Auto-generated method stub
 		try {
-			socket = service.accept();
-			open();
 			boolean done = false;
 			while (!done) {
 				try {
-					String curLine = streamIn.readUTF();
-					System.out.println(curLine);
-					done = curLine.equals(".bye");
+					List<Connection> conns = helper.getConnections();
+					System.out.println(done);
+					synchronized(conns){
+						List<String> text = new ArrayList<String>();
+						for(int i=0; i<conns.size(); i++){
+							Connection curr = conns.get(i);
+							String line = "";
+							if(curr == null || curr.isSocketClosed()){
+								System.out.println("Socket is closed");
+								conns.set(i, null);
+							} else {
+								DataInputStream input = curr.getInputStream();
+								line = input.readUTF();
+								System.out.println(line);
+							}
+							text.add(line);
+							System.out.println(text);
+						}
+						for(int i=0; i<conns.size(); i++){
+							Connection curr = conns.get(i);
+							if(curr == null){
+								
+							} else {
+								DataOutputStream output = curr.getOutputStream();
+								for(int j=0; j<conns.size(); j++){
+									if(j!=i){
+										output.writeUTF(text.get(j));
+										output.writeUTF("\n");
+										output.flush();
+									}
+								}
+							}
+						}
+					}
+
 				} catch (IOException ioe) {
 					done = true;
+					System.out.println("IOException... exiting");
 				}
 			}
 			close();

src/ChatServerHelper.java

@@ -0,0 +1,53 @@
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.SocketTimeoutException;
+import java.util.ArrayList;
+import java.util.List;
+
+
+public class ChatServerHelper implements Runnable{
+
+	public Thread thread = null;
+	private List<Connection> connList = null;
+	private ServerSocket service = null;
+	private boolean stopServer = false;
+	
+	public ChatServerHelper(ServerSocket service){
+		this.service = service;
+		connList = new ArrayList<Connection>();
+		if (thread == null) {
+			thread = new Thread(this);
+			thread.start();
+		}
+	}
+	
+	@Override
+	public void run() {
+		// TODO Auto-generated method stub
+		while (!stopServer) {
+			try {
+				System.out.println("Looking for new socket");
+				Socket newSocket = service.accept();
+				Connection newConnection = new Connection(newSocket);
+				synchronized (connList) {
+					connList.add(newConnection);
+				}
+			} catch (SocketTimeoutException e) {
+				
+			} catch (IOException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+		}
+	}
+	
+	public List<Connection> getConnections(){
+		return connList;
+	}
+	
+	public void close(){
+		stopServer = true;
+	}
+
+}

src/Connection.java

@@ -0,0 +1,42 @@
+import java.io.BufferedInputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.Socket;
+
+
+public class Connection {
+	private DataInputStream streamIn = null;
+	private Socket socket = null;
+	private DataOutputStream streamOut = null;
+	
+	public Connection(Socket socket){
+		this.socket = socket;
+		try {
+			this.streamIn = new DataInputStream(new BufferedInputStream(
+					this.socket.getInputStream()));
+			this.streamOut = new DataOutputStream(socket.getOutputStream());
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	public DataInputStream getInputStream(){
+		return streamIn;
+	}
+	
+	public DataOutputStream getOutputStream(){
+		return streamOut;
+	}
+	
+	public boolean isSocketClosed(){
+		return this.socket.isClosed();
+	}
+	
+	public void close() throws IOException{
+		if (streamIn != null) streamIn.close();
+		if (socket != null) socket.close();
+	}
+	
+}