java线程之五 NIO对象

NIO是相对于IO来说的。因为NIO=new IO。从JDK1.4版本以后引进来的。可以说NIO是对IO的补充，

NIO是对IO的进一步封装，解决了原本IO自身堵塞的问题(虽然可以通过线程来解决，但是占用了大量的CPU资源)

简单来说，NIO有缓存Buffer对象，通过Channel来存储和读写Buffer。提供了Charset对象来实现Unicode与其他字符间

的转换，最后通过Selector来完成非堵塞开发。

关于NIO与IO区别 可以参考以下文章

http://www.dewen.org/q/9648

http://tutorials.jenkov.com/java-nio/nio-vs-io.html

下班了，直接上代码

服务端代码

/**
 * @author draem0507@gmail.com
 * @TODO java 线程之五 nio nio介绍 在1.4以后的JDK中出现了new io 特性主要表现在 1.非阻塞(不用单独开线程来模拟)
 *       2.字符转换 3.缓冲及其通道 新增了四个重要的类 1.Buffer 缓冲区 2.Charset 提供了Unicode与其他字符编码之间的转换
 *       3.Channel 数据传输通道 将Buffer的数据进行写入或则读取 4.Selector 用来支持异步的I/O操作
 *       参考资料:http://blog.chinaunix.net/uid-24186189-id-2623973.html
 * @version 1.0
 * @date 2013-5-8 15:26:45
 * @blgos http://www.cnblogs.com/draem0507
 */
public class ServerTest {
    private ByteBuffer _buffer = ByteBuffer.allocate(16);
    private IntBuffer _intBuffer = _buffer.asIntBuffer();
    private SocketChannel clientChannel;
    private ServerSocketChannel serverSocketChannel;

    public ServerTest() {
    }

    private void startServer() {
        openConnection();
        listenConnection();

    }

    private void listenConnection() {
        // 单线程模拟

        /*
         * while (true) { try { clientChannel = serverSocketChannel.accept(); if
         * (null != clientChannel) { System.out.println("新的客户端连接"); // 进行请求操作
         * Thread.sleep(5000);
         * 
         * doRequest(); // 关闭socket clientChannel.close(); } } catch
         * (IOException e) { // TODO Auto-generated catch block
         * e.printStackTrace(); } catch (InterruptedException e) { // TODO
         * Auto-generated catch block e.printStackTrace(); }
         *  }
         */
        // 多线程模式
        // openConnection方法中开启非堵塞模式
        // 引入selector
        try {
            Selector selector = SelectorProvider.provider().openSelector();
            // 注册selector对象到套接字对象并设置为accept 告诉selector套接字对象操作I/O时希望使用非堵塞模式
            SelectionKey key = serverSocketChannel.register(selector,
                    SelectionKey.OP_ACCEPT);
            int addKey = 0;
            while ((addKey = selector.select()) > 0) {

                Set readyKeys = selector.selectedKeys();
                Iterator i = readyKeys.iterator();
                // 遍历ready键集合，并处理加法请求
                while (i.hasNext()) {
                    SelectionKey sk = (SelectionKey) i.next();
                    i.remove();
                    ServerSocketChannel nextReady = (ServerSocketChannel) sk
                            .channel();
                    // 接受加法请求并处理它
                    clientChannel = nextReady.accept();
                    //为了方便测试 这里加入时间
                    
                    Thread.sleep(5000);
                    doRequest();
                    clientChannel.close();
                }
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    private void doRequest() {
        _buffer.clear();
        try {
            clientChannel.read(_buffer);
            int req = _intBuffer.get(0);
            _buffer.flip();
            _buffer.clear();
            _intBuffer.put(0, req * 2);
            clientChannel.write(_buffer);

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

    }

    private void openConnection() {
        try {
            serverSocketChannel = ServerSocketChannel.open();
            // new ServerSocket(10000);内部也是实现了bind 间接说明NIO是在IO的基础上进行了封装
            // 而不同的地方不在于如何创建对象 而是对象的读取写入(缓存)监听客户端连接的方式(selector)等区别
            serverSocketChannel.socket().bind(new InetSocketAddress(10000));
            // 非堵塞模式 开关默认
            serverSocketChannel.configureBlocking(false);

            System.out.println("服务器已经开始连接");
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
        new ServerTest().startServer();
    }

}

客户端代码

public class ClientTest {
    private SocketChannel channel;
    private ByteBuffer _buffer=ByteBuffer.allocate(16);
    private IntBuffer _intBuffer=_buffer.asIntBuffer();

    public ClientTest() {
    }

    private void conn() {

        connServer();
        sendRequest();
        int resp=receiveRequest();
        System.out.println("收到服务端的结果:"+resp);

    }

    private int  receiveRequest() {
        _buffer.clear();
        try {
            channel.read(_buffer);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return _intBuffer.get(0);
        
    }

    private void sendRequest() {
        
        _buffer.clear();
        int send=(int)(Math.random()*5)+1;
        _intBuffer.put(0, send);
        try {
            channel.write(_buffer);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("发送数据:"+send);
        
    }

    private void connServer() {
        InetSocketAddress remote = new InetSocketAddress("localhost", 10000);
        try {
            channel=SocketChannel.open(remote);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        new ClientTest().conn();
    }

}