BIO编程

BIO 的实现代码

　　在实际的工作开发中，传统的模型有client/service模型。client端和service端要进行通信的话，有一种套接字的方式。传统的socket编程，包含一个socket服务端和一到多个socket客户端。在连接过程中，sokcetServer 绑定一个端口进行监听。client端通过ip地址和端口号对服务进行访问。在服务进入到service端后，service端新建一个线程。线程对请求进行相应的处理，处理完毕后，将处理结果返回给client端。在处理过程中，连接client阻塞。

　　代码实现：

　　server端代码：

　　

　　

　　client端代码：

　　

　　优点：传统的BIO模型进行通信，代码可读性比较强，理解容易。运行中，server端通过主线程监听accpet()方法阻塞式获取server的消息。

　　缺点：该模型最大的问题是，每一个client端访问都对应一个后台的线程，使得系统不具备弹性伸缩能力。一旦client请求过多，线程数会迅速膨胀，系统性能会急剧下降，导致堆栈溢出，进程宕机等问题的发生。

　　为了改进线程数过多，导致系统宕机的问题，同时也为了解决创建线程的消耗问题。后来又演进出了一种通过线程池或者消息队列实现1个或者多个线程处理N个客户端的模型，由于它的底层通信机制依然使用同步阻塞IO，所以被称为 “伪异步”。其原理就是在原来的service上新增一个线程池，将处理业务的线程通过线程池进行管理。如果线程数量到达上限时，将请求先存入queue中进行缓冲。具体代码如下：

　　client端代码不变。

　　server端：　　

import java.io.BufferedReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {

    final static int PORT = 8765;

    public static void main(String[] args) {
        ServerSocket server = null;
        BufferedReader in = null;
        PrintWriter out = null;
        try {
            server = new ServerSocket(PORT);
            System.out.println("server start");
            Socket socket = null;
            HandlerExecutorPool executorPool = new HandlerExecutorPool(50, 50);
            while(true){
                socket = server.accept();
                
                executorPool.execute(new ServerHandler(socket));
                
            }
            
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(in != null){
                try {
                    in.close();
                } catch (Exception e1) {
                    e1.printStackTrace();
                }
            }
            if(out != null){
                try {
                    out.close();
                } catch (Exception e2) {
                    e2.printStackTrace();
                }
            }
            if(server != null){
                try {
                    server.close();
                } catch (Exception e3) {
                    e3.printStackTrace();
                }
            }
            server = null;                
        }
        
    
    
    }
    
    
}

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


public class HandlerExecutorPool {
    private ArrayBlockingQueue queue ;
    private ThreadPoolExecutor executor;
    public HandlerExecutorPool(int maxPoolSize, int queueSize){
        queue = new ArrayBlockingQueue<Runnable>(queueSize);
        this.executor = new ThreadPoolExecutor(
                5,
                maxPoolSize, 
                120L, 
                TimeUnit.SECONDS,
                queue);
    }
    
    public void execute(Runnable task){
        System.out.println("corePoolSize== "+executor.getCorePoolSize());
        System.out.println("queuesize=="+queue.size());
        this.executor.execute(task);
        
        System.out.println("当前运行线程== "+executor.getLargestPoolSize());
        System.out.println("queuesize=="+queue.size());
    }
    
    
    
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.concurrent.TimeUnit;

public class ServerHandler implements Runnable {

    private Socket socket;
    public ServerHandler (Socket socket){
        this.socket = socket;
    }
    
    @Override
    public void run() {
        BufferedReader in = null;
        PrintWriter out = null;
        try {
            Thread.currentThread().sleep(1000);
            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("Server response");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(in != null){
                try {
                    in.close();
                } catch (Exception e1) {
                    e1.printStackTrace();
                }
            }
            if(out != null){
                try {
                    out.close();
                } catch (Exception e2) {
                    e2.printStackTrace();
                }
            }
            if(socket != null){
                try {
                    socket.close();
                } catch (Exception e3) {
                    e3.printStackTrace();
                }
            }
            socket = null;            
        }
        
        
    }

}

　　这样改造后，有效的缓解了server端线程数过多时宕机的问题，但是依然没有解决阻塞的问题。依然会出现请求过多时，前台等待超时的问题。