TCP异步IO_服务端_测试

1、测试代码来自于 JDK7 AIO初体验 http://www.iteye.com/topic/1113611

　　1.1、

package aio;

import java.net.InetSocketAddress;
import java.nio.*;
import java.nio.channels.*;
import java.util.concurrent.*;

public class TaioServer
{
    public final static int PORT = 9888;
    private AsynchronousServerSocketChannel FasyncServer;

    public TaioServer() throws Exception
    {
        FasyncServer = AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(PORT));
    }

    // Future方式
    public void StartWithFuture() throws Exception
    {
        System.out.println("Server listen on " + PORT);
        Future<AsynchronousSocketChannel> future = FasyncServer.accept();
        AsynchronousSocketChannel socket = future.get();
        ByteBuffer readBuf = ByteBuffer.allocate(1024);
        readBuf.clear();
        socket.read(readBuf).get(100, TimeUnit.SECONDS);
        readBuf.flip();
        System.out.printf("received message:" + new String(readBuf.array()));
        System.out.println(Thread.currentThread().getName());
    }
    
    // CompletionHandler方式
    public void StartWithCompletionHandler() throws Exception
    {
        System.out.println("Server listen on " + PORT);
        //注册事件和事件完成后的处理器
        FasyncServer.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>()
            {
                final ByteBuffer buffer = ByteBuffer.allocate(1024);
                
                public void completed(AsynchronousSocketChannel _rstAsyncSocketChannel,  Object _attachment)
                {
                    System.out.println(Thread.currentThread().getName());
                    System.out.println("start");
                    try
                    {
                        buffer.clear();
                        System.out.println("TimeUnit.SECONDS : "+TimeUnit.SECONDS);
                        int iRst = _rstAsyncSocketChannel.read(buffer).get(100, TimeUnit.SECONDS);
                        System.out.println("iRst : "+iRst);
                        buffer.put(iRst, (byte)0);
                        buffer.flip();
                        System.out.println("received message: "+ new String(buffer.array(), 0, iRst));
                    } catch (InterruptedException | ExecutionException e) {
                        //System.out.println(e.toString());
                        e.printStackTrace();
                    } catch (TimeoutException e) {
                        e.printStackTrace();
                    } finally {
                        try
                        {
                            _rstAsyncSocketChannel.close();
                            FasyncServer.accept(null, this);
                        } catch (Exception e) {
                            //System.out.println(e.toString());
                            e.printStackTrace();
                        }
                    }
                    System.out.println("end");
                } // completed(...)
                
                @Override
                public void failed(Throwable exc, Object attachment)
                {
                    System.out.println("failed: " + exc);
                }
            }); // FasyncServer.accept(...)
        
        // 主线程继续自己的行为
        while (true)
        {
            System.out.println("main thread");
            Thread.sleep(1000);
        }
    }
    
    public static void main(String args[]) throws Exception
    {
        System.out.println("main in <<==");
        new TaioServer().StartWithCompletionHandler();
        System.out.println("main out ==>>");
    }
}

　　1.2、

package aio;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.util.concurrent.Future;

public class TaioClient
{
    // http://yunhaifeiwu.iteye.com/blog/1714664
    public static void main(String[] args) throws Exception
    {
        AsynchronousSocketChannel client = AsynchronousSocketChannel.open();
        Future<Void> futureConn = client.connect(new InetSocketAddress("localhost", 9888));
        futureConn.get(); // Future<?>.get();等待异步事件的完成
        Future<Integer> futureWrite = client.write(ByteBuffer.wrap("testAA".getBytes()));
        int iWritten = futureWrite.get();
        System.out.println("Client send ["+iWritten+"] bytes .");
    }
}

2、

3、