How should I handle using this socket on multiple threads?

Question

Hey there, I'm writing a SocketServer app to handle client communications and I've run into something I'm not sure how to handle. Currently, I have the main method create the SocketServer and start new threads whenever a client connects and keeps a list of clients that need to be updated with some info ("Stuff") (Basically a list, which when changed, each update will be sent to all clients on the list to be informed of updates). Each thread that's created when a new client connects is passed the instance of the 'PoolHandler' class, which is supposed to handle updates to the "Stuff" and send updates to any clients that need them. Currently, when a client adds itself to the list of users that need to be informed of updates on "Stuff", the thread that handles that client adds the client name and socket to a hashmap in 'PoolHandler' and anytime the "Stuff" is updated, 'PoolHandler' accesses the passed socket and sends the updates. I realize I'm probably not doing a very good job of explaining this, so I'll show my code:
public static void main(String[] args) throws IOException {
        final PoolHandler pool = new PoolHandler();
        ServerSocket serverSocket = null;
        while (listening) {
            new SNMultiServerThread(clients, pool, serverSocket.accept()).run();
public class SNMultiServerThread implements Runnable {
    public void run() {
        try {
            out = new BufferedOutputStream(socket.getOutputStream());
            in = new BufferedInputStream(socket.getInputStream());
            try {
                while ((read = in.read(input)) > 0) {
                    outputList = snp.process(input);
                    if (outputList != null && !outputList.isEmpty()) {
                        for (byte[] output : outputList) {
                            System.out.println("Transmitting: " +
                                    new String(output, 0, output.length));
                            synchronized(socket) {
                                out.write(output);
                                out.flush();
            } catch (SocketException e) {
public class PoolHandler {
    public PoolHandler() {
    private void updateClients(String update, String game, String team) throws IOException {
        if (update.equalsIgnoreCase("add")) {
            if (game.equalsIgnoreCase(CS)) {
                clientUpdateListDummy = clientUpdateListCs;
            } else {
            // The HashMap here is K=String, V=Socket
            for (Map.Entry<String, Socket> m : clientUpdateListDummy.entrySet()) {
                try {
                    out = new BufferedOutputStream(m.getValue().getOutputStream());
                    out.write(snp.prepareOutput(ADD_TEAM_REPLY, team));
                    out.flush();
                } catch (SocketException e) {
        } else if (update.equalsIgnoreCase("remove")) {
            if (game.equalsIgnoreCase(CS)) {
                clientUpdateListDummy = clientUpdateListCs;
            } else {
            // The HashMap here is K=String, V=Socket
            for (Map.Entry<String, Socket> m : clientUpdateListDummy.entrySet()) {
                try {
                    out = new BufferedOutputStream(m.getValue().getOutputStream());
                    synchronized(m.getValue()) { // synchronizing on the socket connected to the client, m.getValue()
                        out.write(snp.prepareOutput(REMOVE_TEAM_REPLY, team));
                        out.flush();
                } catch (SocketException e) {
}I attempted adding a synchronized block in the second for loop in PoolHandler, although i'm not sure if I need one at all or if that'll do the trick. The question, I guess, is should I be accessing the socket and then the outputstream for it from here (perhaps with the synchronized block that I added in the second for loop)? Or should I perhaps add a method in the Runnable class that transmits data via the socket and call that from PoolHandler? If I go with the second approach, can I simply pass the thread's name instead of the socket and use, say, m.getValue().transmitThisDataOverTheSocket(myData)? Thanks again, I hope this is clear. :)

Answer 1

So I've got another question about my code: will the PoolHandler class be responsive if used in the main() thread or do I need to implement Runnable in it and create a new thread also? If so, how should I go about it since I don't want PoolHandler to do anything other than keep track of clients and a few other client-related variables? Here's my main():
public static void main(String[] args) throws IOException {
        final PoolHandler pool = new PoolHandler();
        ServerSocket serverSocket = null;
        boolean listening = true;
        final int port = 4555;
        try {
            serverSocket = new ServerSocket(port);
        } catch (IOException e) {
            System.err.println("Couldn't listen on port: " + port);
            System.exit(-1);
        while (listening) {
            new SNThreadReader(pool, serverSocket.accept()).run();
        serverSocket.close();
    }