import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.net.UnknownHostException;

public class TestASClient {

	/**
	 * 
	 * @param args
	 * @throws InterruptedException
	 */
	public static void main(String[] args) throws InterruptedException {
		
// запускаем подключение сокета по известным координатам и нициализируем приём сообщений с консоли клиента		
		try(Socket socket = new Socket("localhost", 3345);	
				BufferedReader br =new BufferedReader(new InputStreamReader(System.in));
				DataOutputStream oos = new DataOutputStream(socket.getOutputStream());
				DataInputStream ois = new DataInputStream(socket.getInputStream());	)
		{
			
			System.out.println("Client connected to socket.");
			System.out.println();
			System.out.println("Client writing channel = oos & reading channel = ois initialized.");			
					
// проверяем живой ли канал и работаем если живой			
				while(!socket.isOutputShutdown()){

// ждём консоли клиента на предмет появления в ней данных					
					if(br.ready()){
						
// данные появились - работаем						
			System.out.println("Client start writing in channel...");
			Thread.sleep(1000);
			String clientCommand = br.readLine();
			
// пишем данные с консоли в канал сокета для сервера			
			oos.writeUTF(clientCommand);
			oos.flush();
			System.out.println("Clien sent message " + clientCommand + " to server.");
			Thread.sleep(1000);
// ждём чтобы сервер успел прочесть сообщение из сокета и ответить		

// проверяем условие выхода из соединения			
			if(clientCommand.equalsIgnoreCase("quit")){

// если условие выхода достигнуто разъединяемся				
				System.out.println("Client kill connections");
				Thread.sleep(2000);
				
// смотрим что нам ответил сервер на последок перед закрытием ресурсов			
				if(ois.available()!=0)		{	
					System.out.println("reading...");
					String in = ois.readUTF();
					System.out.println(in);
							}
				
// после предварительных приготовлений выходим из цикла записи чтения				
				break;				
			}

// если условие разъединения не достигнуто продолжаем работу			
			System.out.println("Client sent message & start waiting for data from server...");			
			Thread.sleep(2000);
			
// проверяем, что нам ответит сервер на сообщение(за предоставленное ему время в паузе он должен был успеть ответить)			
			if(ois.available()!=0)		{	
						
// если успел забираем ответ из канала сервера в сокете и сохраняем её в ois переменную,  печатаем на свою клиентскую консоль						
			System.out.println("reading...");
			String in = ois.readUTF();
			System.out.println(in);
					}			
				}
			}
// на выходе из цикла общения закрываем свои ресурсы
			System.out.println("Closing connections & channels on clentSide - DONE.");

		} catch (UnknownHostException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

• 3) Многопоточный сервер

• Фабрика:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


/**
 * @author mercenery
 *
 */
public class MultiThreadServer {

	static ExecutorService executeIt = Executors.newFixedThreadPool(2);

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		// стартуем сервер на порту 3345 и инициализируем переменную для обработки консольных команд с самого сервера
		try (ServerSocket server = new ServerSocket(3345);
				BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {
			System.out.println("Server socket created, command console reader for listen to server commands");

			// стартуем цикл при условии что серверный сокет не закрыт
			while (!server.isClosed()) {

				// проверяем поступившие комманды из консоли сервера если такие
				// были
				if (br.ready()) {
					System.out.println("Main Server found any messages in channel, let's look at them.");

					// если команда - quit то инициализируем закрытие сервера и
					// выход из цикла раздачии нитей монопоточных серверов
					String serverCommand = br.readLine();
					if (serverCommand.equalsIgnoreCase("quit")) {
						System.out.println("Main Server initiate exiting...");
						server.close();
						break;
					}
				}

				// если комманд от сервера нет то становимся в ожидание
				// подключения к сокету общения под именем - "clientDialog" на
				// серверной стороне
				Socket client = server.accept();

				// после получения запроса на подключение сервер создаёт сокет
				// для общения с клиентом и отправляет его в отдельную нить
				// в Runnable(при необходимости можно создать Callable)
				// монопоточную нить = сервер - MonoThreadClientHandler и тот
				// продолжает общение от лица сервера
				executeIt.execute(new MonoThreadClientHandler(client));
				System.out.print("Connection accepted.");
			}

			// закрытие пула нитей после завершения работы всех нитей
			executeIt.shutdown();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

• Модифицированный Runnable сервер для запуска из предыдущего кода:

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;

public class MonoThreadClientHandler implements Runnable {

	private static Socket clientDialog;

	public MonoThreadClientHandler(Socket client) {
		MonoThreadClientHandler.clientDialog = client;
	}

	@Override
	public void run() {

		try {
			// инициируем каналы общения в сокете, для сервера

			
			// канал записи в сокет следует инициализировать сначала канал чтения для избежания блокировки выполнения программы на ожидании заголовка в сокете
			DataOutputStream out = new DataOutputStream(clientDialog.getOutputStream());

// канал чтения из сокета
			DataInputStream in = new DataInputStream(clientDialog.getInputStream());
			System.out.println("DataInputStream created");

			System.out.println("DataOutputStream  created");
			///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
			// основная рабочая часть //
			//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

			// начинаем диалог с подключенным клиентом в цикле, пока сокет не
			// закрыт клиентом
			while (!clientDialog.isClosed()) {
				System.out.println("Server reading from channel");

				// серверная нить ждёт в канале чтения (inputstream) получения
				// данных клиента после получения данных считывает их
				String entry = in.readUTF();

				// и выводит в консоль
				System.out.println("READ from clientDialog message - " + entry);

				// инициализация проверки условия продолжения работы с клиентом
				// по этому сокету по кодовому слову - quit в любом регистре
				if (entry.equalsIgnoreCase("quit")) {

					// если кодовое слово получено то инициализируется закрытие
					// серверной нити
					System.out.println("Client initialize connections suicide ...");
					out.writeUTF("Server reply - " + entry + " - OK");
					Thread.sleep(3000);
					break;
				}

				// если условие окончания работы не верно - продолжаем работу -
				// отправляем эхо обратно клиенту

				System.out.println("Server try writing to channel");
				out.writeUTF("Server reply - " + entry + " - OK");
				System.out.println("Server Wrote message to clientDialog.");

				// освобождаем буфер сетевых сообщений
				out.flush();

				// возвращаемся в началло для считывания нового сообщения
			}

			///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
			// основная рабочая часть //
			//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

			// если условие выхода - верно выключаем соединения
			System.out.println("Client disconnected");
			System.out.println("Closing connections & channels.");

			// закрываем сначала каналы сокета !
			in.close();
			out.close();

			// потом закрываем сокет общения с клиентом в нити моносервера
			clientDialog.close();

			System.out.println("Closing connections & channels - DONE.");
		} catch (IOException e) {
			e.printStackTrace();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

• 4) Имитация множественного обращения клиентов к серверу.

import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {

	// private static ServerSocket server;

	public static void main(String[] args) throws IOException, InterruptedException {

		// запустим пул нитей в которых колличество возможных нитей ограничено -
		// 10-ю.
		ExecutorService exec = Executors.newFixedThreadPool(10);
		int j = 0;

		// стартуем цикл в котором с паузой в 10 милисекунд стартуем Runnable
		// клиентов,
		// которые пишут какое-то количество сообщений
		while (j < 10) {
			j++;
			exec.execute(new TestRunnableClientTester());
			Thread.sleep(10);
		}
		
		// закрываем фабрику
		exec.shutdown();
	}
}

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;

public class TestRunnableClientTester implements Runnable {

	static Socket socket;

	public TestRunnableClientTester() {
		try {

			// создаём сокет общения на стороне клиента в конструкторе объекта
			socket = new Socket("localhost", 3345);
			System.out.println("Client connected to socket");
			Thread.sleep(2000);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	@Override
	public void run() {

		try (

				// создаём объект для записи строк в созданный скокет, для
				// чтения строк из сокета
				// в try-with-resources стиле
				DataOutputStream oos = new DataOutputStream(socket.getOutputStream());
				DataInputStream ois = new DataInputStream(socket.getInputStream())) {
			System.out.println("Client oos & ois initialized");

			int i = 0;
			// создаём рабочий цикл
			while (i < 5) {

				// пишем сообщение автогенерируемое циклом клиента в канал
				// сокета для сервера
				oos.writeUTF("clientCommand " + i);

				// проталкиваем сообщение из буфера сетевых сообщений в канал
				oos.flush();

				// ждём чтобы сервер успел прочесть сообщение из сокета и
				// ответить
				Thread.sleep(10);
				System.out.println("Client wrote & start waiting for data from server...");

				// забираем ответ из канала сервера в сокете
				// клиента и сохраняем её в ois переменную, печатаем на
				// консоль
				System.out.println("reading...");
				String in = ois.readUTF();
				System.out.println(in);
				i++;
				Thread.sleep(5000);

			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}