import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.*;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
 
public class Server {
    final static int PORT = 12100;
    Thread processThread;
 
    public Server() {
        try {
            processThread = new ProcessThread(new ServerSocket(PORT));
            processThread.start();
        } catch(IOException ex) {
            ex.printStackTrace();
        }
    }
 
    private class ProcessThread extends Thread {
        ServerSocket server;
        ExecutorService requestPool;
 
        public ProcessThread(ServerSocket server){
            this.server = server;
            requestPool = Executors.newCachedThreadPool();
        }
 
        public void run() {
            try {
                System.out.println("server waiting to process..");
                while(true) {
                    Socket sock = server.accept();
                    // start an UpdateTask for this client
                    requestPool.submit(new UpdateTask(sock));
                    sleep(100);
                }
            } catch(IOException ex) {
                ex.printStackTrace();
            } catch(InterruptedException e) {
                   // Disable new tasks from being submitted
                   requestPool.shutdown(); 
                   try {
                     // Wait a while for existing tasks to terminate
                     if (!requestPool.awaitTermination(60, TimeUnit.SECONDS)) {
                       // Cancel currently executing tasks
                       requestPool.shutdownNow(); 
                       // Wait a while for tasks to respond to being cancelled
                       if (!requestPool.awaitTermination(60, TimeUnit.SECONDS))
                           System.err.println("Pool did not terminate");
                     }
                   } catch (InterruptedException ie) {
                     // (Re-)Cancel if current thread also interrupted
                     requestPool.shutdownNow();
                     // Preserve interrupt status
                     Thread.currentThread().interrupt();
                   }
                Thread.currentThread().interrupt();
            }
        }
    }
 
    public void shutdown(){
        if (processThread != null && processThread.isAlive()){
            processThread.interrupt();
        }
    }
 
    /** This is the task that will be executed for each client 
     *  on the CachedThreadPool */
    private class UpdateTask implements Callable<String> {
        Socket client;
        String clientName;
 
        public UpdateTask(Socket client){
            this.client = client;
        }
        public String call() throws Exception {
            BufferedReader rd = new BufferedReader(
              new InputStreamReader(client.getInputStream()));
            PrintWriter wr = new PrintWriter(
              new OutputStreamWriter(client.getOutputStream()),true);
 
            // process input from the client
            String str;
            while ((str = rd.readLine()) != null) {
                System.out.println(str);
                if (str.endsWith("calling")){
                    clientName = str.substring(0,str.indexOf(" calling"));
                    wr.println("Go ahead, "+clientName);
                }
                if (str.startsWith("update")){
                    wr.println("updating "+clientName);
                }
                if (str.startsWith("got it")){
                    wr.println("bye "+clientName);
                }
            }
            rd.close();
            System.out.println(clientName+" finished");
            return "Ok, done";
        }
    }
 
    public static void main(String[] args) {
        new Server();
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;
import java.net.SocketTimeoutException;
import java.net.UnknownHostException;
 
public class Launcher {
 
    final static int PORT = 12100;
    String client;
 
    public Launcher(String client) {
        this.client = client;
 
        // Create a socket with a timeout
        try {
            InetAddress addr = InetAddress.getByName("localhost");
            int port = 12100;
            SocketAddress sockaddr = new InetSocketAddress(addr, port);
 
            // Create an unbound socket
            Socket sock = new Socket();
 
            // This method will block no more than timeoutMs.
            // If the timeout occurs, SocketTimeoutException is thrown.
            int timeoutMs = 2000;   // 2 seconds
            sock.connect(sockaddr, timeoutMs);
            System.out.println(client+" connected");
 
            PrintWriter wr = new PrintWriter(
              new OutputStreamWriter(sock.getOutputStream()), true);
            BufferedReader rd = new BufferedReader(
              new InputStreamReader(sock.getInputStream()));
 
            // send something to server
            wr.println(client+" calling");
 
            // read server response
            String str;
            while((str = rd.readLine())!=null) {
                System.out.println(str);
                if (str.startsWith("Go ahead")){
                    wr.println("update me");
                }
                if (str.startsWith("updating")){
                    wr.println("got it");
                }
                if (str.startsWith("bye")){
                    break;
                }
            }
 
            rd.close();
            wr.close();
            sock.close();
        } catch(UnknownHostException e) {
            e.printStackTrace();
        } catch(SocketTimeoutException e) {
            e.printStackTrace();
        } catch(IOException e) {
            e.printStackTrace();
        }
    }
 
    public static void main(String[] args) {
        // start up two client threads
        new Thread(new Runnable() {
            public void run() {
                new Launcher("Bob");
            }
        }).start();
 
        new Thread(new Runnable() {
            public void run() {
                new Launcher("Mary");
            }
        }).start();
    }
}

 
import java.io.*; // for ObjectInputStream and ObjectOutputStream classes
import java.net.*; // for Socket and ServerSocket classes
import java.util.*; // for a Scanner object
import java.util.concurrent.*; // for Executors and ExecutorService classes
 
public class ChatServer{
 
	private ServerSocket ss;
	private Socket theClient[];
	private ObjectInputStream ois[];
	private ObjectOutputStream oos[];
	private ChatServer cs = this;
	private String information = "No information", oldInformation = "No information";
	private boolean update = false;
	private static int numClients = 0;
	private int index = 0;
	static{
		System.out.println("Setting up a test server...");
		System.out.println("How many clients would you like to connect to the server? ");
		numClients = new Scanner(System.in).nextInt();
	}
	private ExecutorService es;
 
	public static void main(String... args){
 
		ChatServer myCS = new ChatServer();
 
		while(true){
			if(!myCS.information.equalsIgnoreCase(myCS.oldInformation)){
				myCS.oldInformation = new String(myCS.information);
				myCS.update = true;
			}
 
			for(ObjectOutputStream element : myCS.oos){
				if((element != null) && myCS.update){
					try{
						element.writeObject(myCS.information + "\n");
					}catch(Exception e){e.printStackTrace();}
				}else continue;
			}
			myCS.update = false;
		}
	}
 
	public ChatServer(){
 
		/*
		 * Server should block for clients
		 * and wait for a connection of at least
		 * one client before displaying information
		 */
 
		try{
			ss = new ServerSocket(6000, numClients); // creates the server at this address, with port 6000 and portQueue numClients
			theClient = new Socket[numClients]; // makes room for numClients amount of clients
			ois = new ObjectInputStream[numClients]; // makes room for numClients amount of ObjectInputStreams
			oos = new ObjectOutputStream[numClients]; // makes room for numClients amount of ObjectOutputStreams
			es = Executors.newFixedThreadPool(numClients);
		}catch(Exception e){e.printStackTrace(); System.exit(1);} // prints the location of the Exception
 
		for(int i = 0; i < numClients; i++){
			try{
				es.submit(new MyThread());
			}catch(Exception e){e.printStackTrace();}
		}
	}
 
	private void sleep(long milliseconds){
		try{Thread.sleep(milliseconds);}catch(Exception e){}
	}
 
	private class MyThread implements Runnable{
		int x = 0;
 
		@Override
		public void run(){
 
			/*Aquires a lock for the out-class - locks other threads from executing until this automic action is finished*/
			synchronized(cs){
				x = index++;
				System.out.println(x);
				try{
					theClient[x] = ss.accept();
					oos[x] = new ObjectOutputStream(theClient[x].getOutputStream());
					oos[x].flush();
					ois[x] = new ObjectInputStream(theClient[x].getInputStream());
				}catch(Exception e){e.printStackTrace();}
			}
 
			while(true){
				System.out.println("Blocking for client number: " + x);
				try{
					information = (String)ois[x].readObject();
					System.out.println("Got new information!");
				}catch(Exception e){e.printStackTrace();}
			}
		}
	}
}
 

 
import java.io.*;
import java.net.*;
import java.util.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.concurrent.*;
 
public class SomeClient extends JFrame implements ActionListener{
 
	private Socket me;
	private ObjectInputStream ois;
	private ObjectOutputStream oos;
	private JTextArea jta;
	private JTextField jtf;
	private ExecutorService es;
 
	public SomeClient(){
 
		setSize(600, 400);
		setLayout(new BorderLayout());
 
		jta = new JTextArea();
		jta.setEditable(false);
		add(BorderLayout.CENTER, jta);
 
		jtf = new JTextField(30);
		jtf.setEditable(true);
		jtf.setActionCommand("JTF");
		jtf.addActionListener(this);
		add(BorderLayout.SOUTH, jtf);
 
		try{
			me = new Socket("127.0.0.1", 6000);
			oos = new ObjectOutputStream(me.getOutputStream());
			oos.flush();
			ois = new ObjectInputStream(me.getInputStream());
		}catch(Exception e){e.printStackTrace();}
		es = Executors.newFixedThreadPool(1);
		es.submit(rt);
	}
 
	Runnable rt = new Runnable(){
		@Override
		public void run(){
			while(true){
				try{
					jta.append((String)ois.readObject());
				}catch(Exception e){e.printStackTrace();}
			}
		}
	};
 
	public static void main(String... args){
		SomeClient sc = new SomeClient();
		sc.setVisible(true);
	}
 
	public void actionPerformed(ActionEvent e){
 
		if(e.getActionCommand().equalsIgnoreCase("JB")){
		}
		else if(e.getActionCommand().equalsIgnoreCase("JTF")){
			try{
				oos.writeObject("<" + me.toString() + "> " + jtf.getText());
				oos.flush();
				jtf.setText("");
			}catch(Exception e2){e2.printStackTrace();}
		}
	}
}