IO编程和NIO编程简介

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author 海晨忆
 * @date 2018/2/9
 * @desc
 */
public class SocketServer {
  private int port = 8080;
  private Socket socket = null;

  public SocketServer(int port) {
    this.port = port;
  }

  public void connect() {
    ServerSocket server = null;
    try {
      server = new ServerSocket(port);
      while (true) {
        socket = server.accept();
        new Thread(new Runnable() {
          @Override
          public void run() {
            new TimerServerHandler(socket).run();
          }
        }).start();
      }
    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      //释放资源
      if (server != null) {
        try {
          server.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
        server = null;
      }
    }
  }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

/**
 * @author 海晨忆
 * @date 2018/2/9
 * @desc
 */
public class TimerServerHandler implements Runnable {
  private Socket socket;

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

  @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 currentTime = null;
      String body = null;
      while (true) {
        body = in.readLine();
        if (body == null)
          break;
      }
    } catch (IOException e) {
      e.printStackTrace();
      //释放in，out，socket资源
    }
  }
}

import com.example.zwang.mysocket.server.TimerServerHandler;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author 海晨忆
 * @date 2018/2/9
 * @desc
 */
public class SocketServer {
  private int port = 8080;
  private Socket socket = null;

  public SocketServer(int port) {
    this.port = port;
  }

  private void connect() {
    ServerSocket server = null;
    try {
      server = new ServerSocket(port);
      TimeServerHandlerExecutePool executePool = new TimeServerHandlerExecutePool(50, 1000);
      while (true) {
        socket = server.accept();
        executePool.execute(new TimerServerHandler(socket));
      }
    } catch (IOException e) {
      e.printStackTrace();
    }finally {
      //释放资源
    }
  }
}

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author 海晨忆
 * @date 2018/2/9
 * @desc
 */
public class TimeServerHandlerExecutePool {
  private ExecutorService executor;

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

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

/**
   * 服务端nio过程的伪代码
   *
   * @param port 端口号
   * @throws IOException IOException
   */
  private void init(int port) throws IOException {
    //第一步：打开ServerSocketChannel，用于监听客户端连接，它是所有客户端连接的父管道
    ServerSocketChannel socketChannel = ServerSocketChannel.open();
    //第二步：监听绑定端口，设置连接模式为非阻塞模式，
    socketChannel.socket().bind(new InetSocketAddress(InetAddress.getByName("IP"), port));
    socketChannel.configureBlocking(false);
    //第三步：创建Reactor线程，创建多路复用器，并启动线程。
    Selector selector = Selector.open();
    new Thread().start();
    //第四步：将ServerSocketChannel注册到Reactor线程的多路复用器上，监听accept事件
    SelectionKey key = socketChannel.register(selector, SelectionKey.OP_ACCEPT/*,ioHandler*/);
    //第五步：多路复用器在线程run方法的无线循环体内轮询准备就绪的key
    int num = selector.select();
    Set<SelectionKey> selectionKeys = selector.selectedKeys();
    Iterator<SelectionKey> it = selectionKeys.iterator();
    while (it.hasNext()) {
      SelectionKey next = it.next();
      //deal with io event...
    }
    //第六步：多路复用器检测到有新客户端接入，处理新的接入请求，完成TCP三次握手，建立物理链路
    SocketChannel channel = socketChannel.accept();
    //第七步：设置客户端为非阻塞模式
    channel.configureBlocking(false);
    channel.socket().setReuseAddress(true);
    //第八步：将新接入的客户端注册到reactor线程的多路复用器上，监听读操作，读取客户端发送的消息
    SelectionKey key1 = socketChannel.register(selector, SelectionKey.OP_ACCEPT/*,ioHandler*/);
    //第九步：异步读取客户端消息到缓冲区，
    /*int readNumber = channel.read("receivebuff");*/
    //第十步：对byteBuffer进行编解码，如果有半包信息指针reset，继续读取到后续的报文，将解码成功消息封装成task，投递到业务线程池，进行业务逻辑编排
    Object massage = null;
    while (buff.hasRemain()) {
      buff.mark();
      Object massage1 = decode(btyeBuffer);
      if (massage1 == null) {
        byteBuffer.reset();
        break;
      }
      massageList.add(massage1);
    }
    if (!byteBuffer.hasRemain()) {
      byteBuffer.clean();
    } else {
      byteBuffer.compact();
    }
    if (massageList != null && !massageList.isEmpty()) {
      for (Object massage3 : massageList){
        handlerTask(massage3);
      }
    }
    //第十一步：将POJO对象encode成ByteBuff，调用SocketChannel的异步write接口，将异步消息发送到客户端
    socketChannel.write(buffer);
  }