java架構《Socket網絡編程基礎篇》

　　　本章主要介紹Socket的基本概念，傳統的同步阻塞式I/O編程，偽異步IO實現，學習NIO的同步非阻塞編程和NIO2.0（AIO）異步非阻塞編程。

　　

目前為止，Java共支持3種網絡編程模型：BIO、NIO、AIO：


Java BIO ： 同步並阻塞，服務器實現模式為一個連接一個線程，即客戶端有連接請求時服務器端就需要啟動一個線程進行處理，如果這個連接不做任何事情會造成不必要的線程開銷，當然可以通過線程池機制改善。
Java NIO ： 同步非阻塞，服務器實現模式為一個請求一個線程，即客戶端發送的連接請求都會注冊到多路復用器上，多路復用器輪詢到連接有I/O請求時才啟動一個線程進行處理。
Java AIO(NIO.2) ： 異步非阻塞，服務器實現模式為一個有效請求一個線程，客戶端的I/O請求都是由OS先完成了再通知服務器應用去啟動線程進行處理。

     BIO、NIO、AIO適用場景分析:


BIO方式適用於連接數目比較小且固定的架構，這種方式對服務器資源要求比較高，並發局限於應用中，JDK1.4以前的唯一選擇，但程序直觀簡單易理解。
NIO方式適用於連接數目多且連接比較短（輕操作）的架構，比如聊天服務器，並發局限於應用中，編程比較復雜，JDK1.4開始支持。
AIO方式使用於連接數目多且連接比較長（重操作）的架構，比如相冊服務器，充分調用OS參與並發操作，編程比較復雜，JDK7開始支持。
　

 

　　一：基本概念

　　　　　　　　Socket又被稱為 "套接字" ，應用程序通常都是通過 "套接字" 向網絡發出請求和接收請求。Socket和serverSocket類位於java.net包中。ServerSocket用於（Server）服務端，Socket用於

　　　　　　（Client）客戶端。當服務端和客戶端建立連接后。兩端都會產生一個Socket實例，並且是平等的。不管是Socket還是ServerSocket。都是通過操作SocketImpl和其子類完成相關功能。

　

　　　　

　　　 連接過程四步驟：　1：服務器監聽  2：客戶端請求   3：服務端連接確認   4：客戶端連接確認

 

　　二：傳統同步阻塞IO實現

　　　　　　　　　　　服務端ServerSocket：

　　　　　　　　　　　　　

　　　　　　　　　　　　　　final static int PROT = 8765;

　　　　　　　　　　　　　　ServerSocket server = null;

　　　　　　　　　　　　　　server = new ServerSocket(PROT);

　　　　　　　　　　　　　　Socket socket = server.accept();  //進行阻塞

　　　　　　　　　　　　　　new Thread(new ServerHandler(socket)).start();  //服務端運行，等待客戶端連接

 

 

　　　　　　　　　客戶端Socket：

　　　　　　　　　　　　　　

　　　　　　　　　　　　　　final static String ADDRESS = "127.0.0.1";

　　　　　　　　　　　　　　final static int PORT = 8765;

　　　　　　　　　　　　　　 Socket socket = null;

　　　　　　　　　　　　　　socket = new Socket(ADDRESS, PORT);  //進行連接

 

　　　　　　

　　　　　　　　　 服務端處理器ServerHandler：

　　　　　　　　　　

　　　　　　　　　　　　　//　實現Runnable

　　　　　　　　　　　　　　　　private Socket socket ;

　　　　　　　　　　　　　　　　public ServerHandler(Socket socket){
　　　　　　　　　　　　　　　　　　this.socket = socket;
　　　　　　　　　　　　　　　　}

　　　　　　　　　　　　　　//重寫run方法：　　　

　　　　　　　　　　　　　　　　@Override
　　　　　　　　　　　　　　　　public void run() {
　　　　　　　　　　　　　　　　BufferedReader in = null;
　　　　　　　　　　　　　　　　PrintWriter out = null;
　　　　　　　　　　　　　　　　　　try {
　　　　　　　　　　　　　　　　　　　　in = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
　　　　　　　　　　　　　　　　　　　　out = new PrintWriter(this.socket.getOutputStream(), true);
　　　　　　　　　　　　　　　　　　　　String body = null;
　　　　　　　　　　　　　　　　　　　　　　while(true){
　　　　　　　　　　　　　　　　　　　　　　　　body = in.readLine();
　　　　　　　　　　　　　　　　　　　　　　　　　　if(body == null) break;
　　　　　　　　　　　　　　　　　　　　　　　　　　　　System.out.println("Server :" + body);
　　　　　　　　　　　　　　　　　　　　　　　　　　　　out.println("服務器端回送響的應數據.");
　　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　　　　} catch (Exception e) {
　　　　　　　　　　　　　　　　　　　　　　e.printStackTrace();

　　　　　　　　　　　　　　　　　　　　}

 

　　

　　三：偽異步實現：

　　　　　　原理：傳統的是直接new Thread()來進行運行任務，現在我們直接通過自定義線程池來實現偽異步。

　　　　　　　

　　　　　　　　　　//之前服務端運行：　　　

　　　　　　　　　　//新建一個線程執行客戶端的任務
　　　　　　　　　　new Thread(new ServerHandler(socket)).start();

 

　　　　　

　　　　　　　　　　//　現在偽異步：

　　　　　　　　　　HandlerExecutorPool executorPool = new HandlerExecutorPool(50, 1000);
　　　　　　　　　　　　while(true){
　　　　　　　　　　　　　　socket = server.accept();
　　　　　　　　　　　　　　executorPool.execute(new ServerHandler(socket));
　　　　　　　　　　　　}

 

　　　　　　自定義線程池：HandlerExecutorPool 

　　　　　　　　　

　　　　　　　　　public class HandlerExecutorPool {

　　　　　　　　　　　　private ExecutorService executor;
　　　　　　　　　　　　public HandlerExecutorPool(int maxPoolSize, int queueSize){
　　　　　　　　　　　　　　this.executor = new ThreadPoolExecutor(
　　　　　　　　　　　　　　Runtime.getRuntime().availableProcessors(),
　　　　　　　　　　　　　　maxPoolSize, 
　　　　　　　　　　　　　　120L, 
　　　　　　　　　　　　　　TimeUnit.SECONDS,
　　　　　　　　　　　　　　new ArrayBlockingQueue<Runnable>(queueSize));
　　　　　　　　　　　　　　}

　　　　　　　　　　　　public void execute(Runnable task){
　　　　　　　　　　　　　　this.executor.execute(task);
　　　　　　　　　　　　}

　　　　　　　　　　}

 

 

　　四：NIO(非阻塞編程)

　　　　　　　　傳統IO和NIO的差異：IO是同步阻塞   NIO是同步非阻塞。 在jdk1.7以后，NIO升級（NIO2.0）AIO，實現了異步非阻塞

　　　　　　　　傳統的IO（BIO）阻塞:在網絡應用程序獲取網絡數據時，如果網絡傳輸數據很慢，那么程序就一直等着，直到傳輸完畢為止。

　　　　　　　　NIO：無需等待，直接獲取數據，在數據沒有傳輸完畢時，不獲取數據，數據暫時放在緩沖區，等傳輸完畢以后，緩沖區發出通知，客戶端獲取數據，實現不等待。

　　　　　　　　

　　　　　　　基本概念：

　　　　　　　　　　Buffer(緩沖區)   channel（管道、通道） Selector（選擇器，多路復用器）

　　　　　　　　　　Buffer注意事項：每次在put()，for循環 之后都要進行flip()復位。要復位下標 

　　　　　　　　　　Buffer常用方法：

　　　　　　　　　　　　　　　　flip()復位：因為buffer和游標類似，每次新增數據之后，它的下標都會自增，如果用for循環遍歷時，他只會遍歷沒有填充的下標的值，所以要用filp()方法復

　　　　　　　　　　　　　　　　　　　　　　位。

　　　　　　　　　　　　　　　   wrap(數組)：wrap方法會包裹一個數組: 一般這種用法不會先初始化緩存對象的長度，因為沒有意義，最后還會被wrap所包裹的數組覆蓋掉

　　　　　　　　　　　　　　　　duplicate(): buffer復制的方法 。一個buffer數據復制給另外一個buffer數組

　　　　　　　　　　　　　　　　position(index)：設置buffer可讀的下標的位置

　　　　　　　　　　　　　　　　remaining() :返回buffer可讀的長度

　　　　　　　　　　　　　　　　get(數組)：把buffer數據復制給數組

　　　　　　　　

　　　　　　　　　Channel管道：雙向

　　　　　　　　　　　　　　　　兩大類： 1：網絡讀寫類（SelectableChannel）   2:文件操作類（FileChannel）

　　　　　　　　　　　　　　　　　　　　我們要使用的SocketChannel和ServerSocketChannel就在SelectableChannel類里面

 

　　　　　　　　　Selector：選擇器（多路復用器）

　　　　　　　　　　　　　　　　原理：Selector不斷的注冊輪詢注冊在其上的通道（SocketChannel），如果某一個通道發生了讀寫操作，這個通道就處於就緒狀態，會被Selector輪詢出

　　　　　　　　　　　　　　　　　　   來。然后通過SelectionKey就可以獲取到就緒的Channel集合，從而進行后續操作。

　　　　　　　　　　　　　　　　四大狀態：連接狀態   阻塞狀態   可讀狀態  可寫狀態

 

　　　　　　　　　　　　

下面來看一下程序中是怎么通過這些類庫實現Socket功能。

 

首先介紹一下幾個輔助類

輔助類SerializableUtil，這個類用來把java對象序列化成字節數組，或者把字節數組反序列化成java對象。

 

package com.googlecode.garbagecan.test.socket;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerializableUtil {

    public static byte[] toBytes(Object object) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(baos);
            oos.writeObject(object);
            byte[] bytes = baos.toByteArray();
            return bytes;
        } catch(IOException ex) {
            throw new RuntimeException(ex.getMessage(), ex);
        } finally {
            try {
                oos.close();
            } catch (Exception e) {}
        }
    }

    public static Object toObject(byte[] bytes) {
        ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(bais);
            Object object = ois.readObject();
            return object;
        } catch(IOException ex) {
            throw new RuntimeException(ex.getMessage(), ex);
        } catch(ClassNotFoundException ex) {
            throw new RuntimeException(ex.getMessage(), ex);
        } finally {
            try {
                ois.close();
            } catch (Exception e) {}
        }
    }
}

輔助類MyRequestObject和MyResponseObject，這兩個類是普通的java對象，實現了Serializable接口。MyRequestObject類是Client發出的請求，MyResponseObject是Server端作出的響應。

 

 

package com.googlecode.garbagecan.test.socket.nio;

import java.io.Serializable;

public class MyRequestObject implements Serializable {

    private static final long serialVersionUID = 1L;

    private String name;

    private String value;

    private byte[] bytes;

    public MyRequestObject(String name, String value) {
        this.name = name;
        this.value = value;
        this.bytes = new byte[1024];
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        StringBuffer sb = new StringBuffer();
        sb.append("Request [name: " + name  + ", value: " + value + ", bytes: " + bytes.length+ "]");
        return sb.toString();
    }
}

package com.googlecode.garbagecan.test.socket.nio;

import java.io.Serializable;

public class MyResponseObject implements Serializable {

    private static final long serialVersionUID = 1L;

    private String name;

    private String value;

    private byte[] bytes;

    public MyResponseObject(String name, String value) {
        this.name = name;
        this.value = value;
        this.bytes = new byte[1024];
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        StringBuffer sb = new StringBuffer();
        sb.append("Response [name: " + name  + ", value: " + value + ", bytes: " + bytes.length+ "]");
        return sb.toString();
    }
}

下面主要看一下Server端的代碼，其中有一些英文注釋對理解代碼很有幫助，注釋主要是來源jdk的文檔和例子，這里就沒有再翻譯

 

 

package com.googlecode.garbagecan.test.socket.nio;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.logging.Level;
import java.util.logging.Logger;

import com.googlecode.garbagecan.test.socket.SerializableUtil;

public class MyServer3 {

    private final static Logger logger = Logger.getLogger(MyServer3.class.getName());

    public static void main(String[] args) {
        Selector selector = null;
        ServerSocketChannel serverSocketChannel = null;

        try {
            // Selector for incoming time requests
            selector = Selector.open();

            // Create a new server socket and set to non blocking mode
            serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.configureBlocking(false);

            // Bind the server socket to the local host and port
            serverSocketChannel.socket().setReuseAddress(true);
            serverSocketChannel.socket().bind(new InetSocketAddress(10000));

            // Register accepts on the server socket with the selector. This
            // step tells the selector that the socket wants to be put on the
            // ready list when accept operations occur, so allowing multiplexed
            // non-blocking I/O to take place.
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

            // Here's where everything happens. The select method will
            // return when any operations registered above have occurred, the
            // thread has been interrupted, etc.
            while (selector.select() > 0) {
                // Someone is ready for I/O, get the ready keys
                Iterator<SelectionKey> it = selector.selectedKeys().iterator();

                // Walk through the ready keys collection and process date requests.
                while (it.hasNext()) {
                    SelectionKey readyKey = it.next();
                    it.remove();

                    // The key indexes into the selector so you
                    // can retrieve the socket that's ready for I/O
                    execute((ServerSocketChannel) readyKey.channel());
                }
            }
        } catch (ClosedChannelException ex) {
            logger.log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            logger.log(Level.SEVERE, null, ex);
        } finally {
            try {
                selector.close();
            } catch(Exception ex) {}
            try {
                serverSocketChannel.close();
            } catch(Exception ex) {}
        }
    }

    private static void execute(ServerSocketChannel serverSocketChannel) throws IOException {
        SocketChannel socketChannel = null;
        try {
            socketChannel = serverSocketChannel.accept();
            MyRequestObject myRequestObject = receiveData(socketChannel);
            logger.log(Level.INFO, myRequestObject.toString());

            MyResponseObject myResponseObject = new MyResponseObject(
                    "response for " + myRequestObject.getName(),
                    "response for " + myRequestObject.getValue());
            sendData(socketChannel, myResponseObject);
            logger.log(Level.INFO, myResponseObject.toString());
        } finally {
            try {
                socketChannel.close();
            } catch(Exception ex) {}
        }
    }

    private static MyRequestObject receiveData(SocketChannel socketChannel) throws IOException {
        MyRequestObject myRequestObject = null;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        try {
            byte[] bytes;
            int size = 0;
            while ((size = socketChannel.read(buffer)) >= 0) {
                buffer.flip();
                bytes = new byte[size];
                buffer.get(bytes);
                baos.write(bytes);
                buffer.clear();
            }
            bytes = baos.toByteArray();
            Object obj = SerializableUtil.toObject(bytes);
            myRequestObject = (MyRequestObject)obj;
        } finally {
            try {
                baos.close();
            } catch(Exception ex) {}
        }
        return myRequestObject;
    }

    private static void sendData(SocketChannel socketChannel, MyResponseObject myResponseObject) throws IOException {
        byte[] bytes = SerializableUtil.toBytes(myResponseObject);
        ByteBuffer buffer = ByteBuffer.wrap(bytes);
        socketChannel.write(buffer);
    }
}

下面是Client的代碼，代碼比較簡單就是啟動了100個線程來訪問Server

 

 

package com.googlecode.garbagecan.test.socket.nio;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.util.logging.Level;
import java.util.logging.Logger;

import com.googlecode.garbagecan.test.socket.SerializableUtil;

public class MyClient3 {

    private final static Logger logger = Logger.getLogger(MyClient3.class.getName());

    public static void main(String[] args) throws Exception {
        for (int i = 0; i < 100; i++) {
            final int idx = i;
            new Thread(new MyRunnable(idx)).start();
        }
    }

    private static final class MyRunnable implements Runnable {

        private final int idx;

        private MyRunnable(int idx) {
            this.idx = idx;
        }

        public void run() {
            SocketChannel socketChannel = null;
            try {
                socketChannel = SocketChannel.open();
                SocketAddress socketAddress = new InetSocketAddress("localhost", 10000);
                socketChannel.connect(socketAddress);

                MyRequestObject myRequestObject = new MyRequestObject("request_" + idx, "request_" + idx);
                logger.log(Level.INFO, myRequestObject.toString());
                sendData(socketChannel, myRequestObject);

                MyResponseObject myResponseObject = receiveData(socketChannel);
                logger.log(Level.INFO, myResponseObject.toString());
            } catch (Exception ex) {
                logger.log(Level.SEVERE, null, ex);
            } finally {
                try {
                    socketChannel.close();
                } catch(Exception ex) {}
            }
        }

        private void sendData(SocketChannel socketChannel, MyRequestObject myRequestObject) throws IOException {
            byte[] bytes = SerializableUtil.toBytes(myRequestObject);
            ByteBuffer buffer = ByteBuffer.wrap(bytes);
            socketChannel.write(buffer);
            socketChannel.socket().shutdownOutput();
        }

        private MyResponseObject receiveData(SocketChannel socketChannel) throws IOException {
            MyResponseObject myResponseObject = null;
            ByteArrayOutputStream baos = new ByteArrayOutputStream();

            try {
                ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
                byte[] bytes;
                int count = 0;
                while ((count = socketChannel.read(buffer)) >= 0) {
                    buffer.flip();
                    bytes = new byte[count];
                    buffer.get(bytes);
                    baos.write(bytes);
                    buffer.clear();
                }
                bytes = baos.toByteArray();
                Object obj = SerializableUtil.toObject(bytes);
                myResponseObject = (MyResponseObject) obj;
                socketChannel.socket().shutdownInput();
            } finally {
                try {
                    baos.close();
                } catch(Exception ex) {}
            }
            return myResponseObject;
        }
    }
}

 

最后測試上面的代碼，首先運行Server類，然后運行Client類，就可以分別在Server端和Client端控制台看到發送或接收到的MyRequestObject或MyResponseObject對象了。　　　

　

代碼實現： 

       　　注：轉自http://blog.csdn.net/kongxx/article/details/7288896

　　　　

 

 

　　五：NIO2.0(AIO) 異步非阻塞

 

　　　　　　AIO編程：在NIO基礎上引入異步的通到的概念，實現了異步文件和異步套字節，jdk1.7以后升級。

　　　　

　　　　　　　　基本概念

　　　　　　　　　　1 AsynchronousChannel：支持異步通道，包括服務端AsynchronousServerSocketChannel和客戶端AsynchronousSocketChannel等實現。
　　　　　　　　　　2 CompletionHandler：用戶處理器。定義了一個用戶處理就緒事件的接口，由用戶自己實現，異步io的數據就緒后回調該處理器消費或處理數據。
　　　　　　　　　　3 AsynchronousChannelGroup：一個用於資源共享的異步通道集合。處理IO事件和分配給CompletionHandler。(具體這塊還沒細看代碼，后續再分析這塊)

 

　　　　

　　　　　　所謂AIO,就是異步非阻塞IO，是NIO的升級版本，也就是NIO2.0版本，但是與NIO不同，當進行讀寫操作時，只須直接調用API的read或write方法即可。這兩種方法均為異步

　　　　　　　　的，對於讀操作而言，當有流可讀取時，操作系統會將可讀的流傳入read方法的緩沖區，並通知應用程序；對於寫操作而言，當操作系統將write方法傳遞的流寫入完畢時，操作

　　　　　　　　系統主動通知應用程序。 即可以理解為，read/write方法都是異步的，完成后會主動調用回調函數。

 

　　　　　　具體代碼實現：

　　　　　　　　　　　

　　　　　　　　　　　//　Server類：　



/**
* 
*類描述：AIO 服務端
*@author: 豪
*@date： 日期：2017-5-24 時間：上午10:48:12
*@version 1.0
*/
public class Server {
//線程池
private ExecutorService executorService;
//線程組
private AsynchronousChannelGroup threadGroup;
//服務器通道
public AsynchronousServerSocketChannel assc;

public Server(int port){
try {
//創建一個緩存池
executorService = Executors.newCachedThreadPool();
//創建線程組
threadGroup = AsynchronousChannelGroup.withCachedThreadPool(executorService, 1);
//創建服務器通道
assc = AsynchronousServerSocketChannel.open(threadGroup);
//進行綁定
assc.bind(new InetSocketAddress(port));

System.out.println("server start , port : " + port);
//進行阻塞
assc.accept(this, new ServerCompletionHandler());
//一直阻塞 不讓服務器停止
Thread.sleep(Integer.MAX_VALUE);

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

public static void main(String[] args) {
Server server = new Server(8765);
}

}

 

 

//ServerCompletionHandler類
 　　

/**
* 
*類描述：服務端處理類 所有的處理都在此類進行
*@author: 豪
*@date： 日期：2017-5-24 時間：上午10:47:45
*@version 1.0
*/
public class ServerCompletionHandler implements CompletionHandler<AsynchronousSocketChannel, Server> {

@Override
public void completed(AsynchronousSocketChannel asc, Server attachment) {
//當有下一個客戶端接入的時候 直接調用Server的accept方法，這樣反復執行下去，保證多個客戶端都可以阻塞
attachment.assc.accept(attachment, this);
read(asc);
}

private void read(final AsynchronousSocketChannel asc) {
//讀取數據
ByteBuffer buf = ByteBuffer.allocate(1024);
asc.read(buf, buf, new CompletionHandler<Integer, ByteBuffer>() {
@Override
public void completed(Integer resultSize, ByteBuffer attachment) {
//進行讀取之后,重置標識位
attachment.flip();
//獲得讀取的字節數
System.out.println("Server -> " + "收到客戶端的數據長度為:" + resultSize);
//獲取讀取的數據
String resultData = new String(attachment.array()).trim();
System.out.println("Server -> " + "收到客戶端的數據信息為:" + resultData);
String response = "服務器響應, 收到了客戶端發來的數據: " + resultData;
write(asc, response);
}
@Override
public void failed(Throwable exc, ByteBuffer attachment) {
exc.printStackTrace();
}
});
}

private void write(AsynchronousSocketChannel asc, String response) {
try {
ByteBuffer buf = ByteBuffer.allocate(1024);
buf.put(response.getBytes());
buf.flip();
asc.write(buf).get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}

@Override
public void failed(Throwable exc, Server attachment) {
exc.printStackTrace();
}

}

 

 

//Clinet類：

/**
* 
*類描述：AIO客戶端
*@author: 豪
*@date： 日期：2017-5-24 時間：上午10:47:23
*@version 1.0
*/
public class Client implements Runnable{

private AsynchronousSocketChannel asc ;

public Client() throws Exception {
asc = AsynchronousSocketChannel.open();
}

public void connect(){
asc.connect(new InetSocketAddress("127.0.0.1", 8765));
}

public void write(String request){
try {
asc.write(ByteBuffer.wrap(request.getBytes())).get();
read();
} catch (Exception e) {
e.printStackTrace();
}
}

private void read() {
ByteBuffer buf = ByteBuffer.allocate(1024);
try {
asc.read(buf).get();
buf.flip();
byte[] respByte = new byte[buf.remaining()];
buf.get(respByte);
System.out.println(new String(respByte,"utf-8").trim());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}

@Override
public void run() {
while(true){

}
}

public static void main(String[] args) throws Exception {
Client c1 = new Client();
c1.connect();

Client c2 = new Client();
c2.connect();

Client c3 = new Client();
c3.connect();

new Thread(c1, "c1").start();
new Thread(c2, "c2").start();
new Thread(c3, "c3").start();

Thread.sleep(1000);

c1.write("c1 aaa");
c2.write("c2 bbbb");
c3.write("c3 ccccc");
}

}