Beginning Threads

[Ben Jass]

Hey guys, just finished reading my first book on Java and I'm working on a Chat Client/Server project so I can dig a little bit into streams, multi-threading, saving objects, etc.

At the moment, I'm a little puzzled.

The way I think this through in my head (and you can tell me if this is completely wrong) is when the server accepts a client,
- I want to create a separate thread for any messages that might come through (text, when people are typing back and forth).
- The other thread is constantly waiting for any Objects that are sent to the Server so I can update the Player list.

This is my code for accepting another client:

public void init() {
		
		playerList = new ArrayList<Player>();
		clientOutputStreams = new ArrayList();
		
		loadPlayers();
		
		try {
			ServerSocket serverSock = new ServerSocket(5000);
			
			while(true) {
				
				Socket clientSocket = serverSock.accept();
				
				PrintWriter writer = new PrintWriter(clientSocket.getOutputStream());
				clientOutputStreams.add(writer);
				
				oos = new ObjectOutputStream(clientSocket.getOutputStream());
				
				Thread t = new Thread(new ClientHandlerText(clientSocket));
				t.start();
				
				Thread j = new Thread(new ClientHandlerObj(clientSocket));
				j.start();
				
				System.out.println("Connection Successful: " + clientSocket.getLocalAddress());
			}
				
		} catch (Exception ex) {
			ex.printStackTrace();
			System.out.println("Connection Unsuccessful: ");
		}
	}

I have two inner classes that implement Runnable and have their own run() methods that are being executed by two threads.
However, the program doesn't want to initialize both threads? If I have them both in there it won't make the second thread?
If I have just one thread created in this procedure than everything works fine?

Please tell me if I'm doing something completely incorrect here. If you need more code, let me know. Keep in mind, this is my FIRST thread project.


PS: After looking this over, is the solution to have another thread constantly just doing the accepting process of clients?

[Stephan van Hulst]

How do you know the program doesn't want to initialize both? If you deduce this from code inside ClientHandlerText and ClientHandlerObj, we should probably see this code.

[Ben Jass]

I've added System.out.println for debugging between threads. The code above won't even finish after the first thread is initialized.

ClientHandlerText:

	public class ClientHandlerText implements Runnable {
	
		BufferedReader reader;
		Socket sock;
		
		public ClientHandlerText(Socket clientSocket) {
			try {
				sock = clientSocket;
				InputStreamReader isReader = new InputStreamReader(sock.getInputStream());
				reader = new BufferedReader(isReader);
				
			} catch (Exception ex) {
				ex.printStackTrace();
			}
		}

		@Override
		public void run() {
			String message;
			
			System.out.println("First Thread Initiliazed.");
			try {
				
				while ((message = reader.readLine()) != null) {
					
					System.out.println("Reading: " + message);
					messageEverybody(message);
				}
				
				reader.close();

			} catch (Exception ex) {
				ex.printStackTrace();
			}
		}
	}

ClientHandlerObjects:

	 /* Client Handling class for any objects sent over the network.
	 * 		- Separate Thread
	 */
	public class ClientHandlerObj implements Runnable {
		
		ObjectInputStream ois;
		Socket sock;
		
		// Initializes socket and input stream
		public ClientHandlerObj(Socket clientSocket) {
			try {
				sock = clientSocket;
				ois = new ObjectInputStream(sock.getInputStream());
				
				System.out.println("Obj Handler Initialized.");
				
			} catch (Exception ex) {
				ex.printStackTrace();
			
			}
		}
		
		
		 // Reads any objects sent through the network, converts to a Player object and stores them into the Server's playerList.
		@Override
		public void run() {
			System.out.println("Second Thread Initiliazed.");
			
			try  {
				Object o;
				
				while ((o = ois.readObject()) != null) {
					
					o = ois.readObject();
					
					if (o != null) {
						
						Player p = (Player) o;
						playerList.add(p);
						oos.writeObject(playerList);
						
					}
				}
				
			} catch (Exception ex) {
				System.out.println("Failed to Retrieve new Player");
			}
			
		}
		
	}

[Stephan van Hulst]

Yeah, you have two different threads reading from the same socket. That's a bad idea. Make one Runnable that's responsible for reading everything from one socket.

[Ben Jass]

So,

- Scratch having two threads
- One thread constantly reading if the client sends an object or a string of text
- Implement code from there accordingly

Correct?

Something like:

		while (true) {
			
			if ((message = reader.readline()) != null) {
				//run code for String of text.
			}
			
			if ((o = ois.readObject()) != null) {
				// run code for objectHandling
			}
		}
		

[Stephan van Hulst]

No, because now you'll be alternating between text and objects, which both come from the same input stream.

You should first develop a protocol describing what input you expect at any given moment, and then attempt to write the thing you expect.

Describe the flow of messages between two clients.

[Ben Jass]

Okay, Yeah I didn't get a whole lot of background for handling multiple types of streams.

- Server Running...

- Client Running...
-> Connects to Server
-> Server sends currentPlayerList to client (So user can login)

- If User needs to create a new player
-> Send new Player to Server so Server can update playerList (...and then saves the playerlist to a file)

- When user logs in (Haven't created this yet)
-> Types message into JTextField
- Sends to Server which disperses it among all clients

This is all I have now, and I only have the GUI for the login window and create new player window