NIO学习笔试(5)-提高篇

 nio最大的特点在于不阻塞，但是如果要写入一个很大的文件，缓冲区满了，所以，程序还是会阻塞。解决的办法是一次只写一小块，这么做的话，就要把每次写的进度保存下来。我们可以利用SelectionKey.attach()方法，把一个selectionKey和一个对象“绑定”起来。

下面写一个小小的DEMO，服务器发送三个字符符给客户机，每次发送一个。

import java.io.BufferedReader;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;


public class Ex3Server {

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

        class Task{
            String[] testList = {
                    "测试1\r\n",
                    "测试2\r\n",
                    "测试3\r\n"
            };
            ByteBuffer buf;
            int pos = -1;

            public Task(){
                buf = ByteBuffer.allocate(1024);
            }

            public ByteBuffer getBuffer(){
                buf.clear();
                pos++;
                if(pos >= testList.length)
                    return null;

                buf.put(testList[pos].getBytes());
                buf.flip();
                return buf;
            }
        }

        //第一件事是创建一个 Selector
        Selector selector = Selector.open();

        //要监听的每一个端口都需要有一个 ServerSocketChannel
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);

        ServerSocket serverSocket = serverSocketChannel.socket();
        serverSocket.bind(new InetSocketAddress(12345));//绑定一个端口

        //SelectionKey 代表这个通道在此 Selector 上的这个注册。
        //当某个 Selector 通知您某个传入事件时，它是通过提供对应于该事件的 SelectionKey 来进行的。
        //SelectionKey 还可以用于取消通道的注册。
        SelectionKey selectionKey = serverSocketChannel.register(
                selector, SelectionKey.OP_ACCEPT);//注册accept事件

        int num = 0;
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        while(true){
            //select方法会阻塞，直到至少有一个已注册的事件发生
            num = selector.select();

            Iterator iterator = selector.selectedKeys().iterator();
            SelectionKey key = null;
            while(iterator.hasNext()){
                 key = iterator.next();
                 if(key.isAcceptable()){//accept
                     ServerSocketChannel channel = (ServerSocketChannel)key.channel();
                     //相当于从ServerSocket中accept一个socket
                     SocketChannel socketChannel = channel.accept();
                     socketChannel.configureBlocking(false);//设为非阻塞
                     socketChannel.register(selector, SelectionKey.OP_READ);

                 }else if(key.isReadable()){
                     SocketChannel channel = (SocketChannel)key.channel();
                     int readNum = 1;
                     while(readNum > 0){
                         buffer.clear();
                         readNum = channel.read(buffer);//读出

                         buffer.flip();


                     }

                     //attach一个对象来保存写入进度
                     channel.register(selector, SelectionKey.OP_WRITE)
                        .attach(new Task());
                     //channel.close();

                 }else if(key.isWritable()){
                     SocketChannel channel = (SocketChannel)key.channel();
                     Task task = (Task) key.p_w_upload();
                     ByteBuffer buf = task.getBuffer();
                     if(buf == null){
                         
      
      
      
      
       
       
       
       key.cancel()
      
      
      
      ; //cancel会把channel也关掉

                         key.interestOps(SelectionKey.OP_READ);//取消掉OP_WRITE
                     }else{
                         channel.write(buf);
//buf.hasRemaining()最好判断一下，因为为了不阻塞可能一次没写完
                     }

                 }
                 iterator.remove();
            }
        }

    }

}

 

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;


public class Ex3Client {

    /**
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        SocketAddress address = new InetSocketAddress("localhost", 12345);
        Socket s = new Socket();
        s.connect(address);
        PrintWriter writer = new PrintWriter( new OutputStreamWriter(s.getOutputStream()));
        writer.println("abc");
        writer.flush();

        BufferedReader reader = new BufferedReader(new InputStreamReader(s.getInputStream()));

        String str;
        do{
            str = reader.readLine();
            System.out.println(str);
        }while(str != null);


        writer.close();
        reader.close();
        s.close();
    }

}

对于读大文件，也可以作类似的处理。

到目前为止，我们都只有利用一个线程来处理所有请求，显然，这样会浪费多核CPU的优势。所以，我们要利用起多线程来。我想到的一种多线程的方式是多线程select()，因为一个channel可以注册到多个Selector上，把ServerSocketChannel注册到多个线程上的Selector上，让多线程竞争accept。另一种多线程的方式：把I/0操作及其它占用时间的操作丢给线程池去完成。还有一种方式，主线程的Selector负责accept,这样可以保证所有连接都被响应，工作线程的Selector去处理读/写请求。不管怎么样，总是不要让多线程去处理同一个SelectionKey（尽管它是线程安全的），因为readyOps( )方法返回的就绪状态指示只是一个提示，不是保证。底层的通道在任何时候都会不断改变。其他线程可能在通道上执行操作并影响它的就绪状态。即使使用线程池的方式，在对一个OP进程响应的时候，反注册掉这个OP，线程工作完后，再注册上这个OP，防止在这个线程工作时，其它线程也操作同一个channel。

另外，当一个请求完成后怎么办？SelectionKey和attach的对象不会自动回收。我的意见是，给每个selectionKey attach一个对象，来记录它们的活动情况，遍历selector.keys()，关闭长时间没活动的channel，相当于keepAlive机制。

一个SelectionKey对应一个Selector上的Channel，通过channel.keyFor(selector)取出相应的SelectionKey。也就是说，一个channel在一个Selector上，读/写都是一个SelectionKey。所以SelectionKey的cancel方法会把整个channel也取消掉，而不是只取消读或写。