java的nio之：java的bio流下实现的socket服务器同步阻塞模型和socket的伪异步的socket服务器的通信模型

同步I/O模型的弊端
===>每一个线程的创建都会消耗服务端内存，当大量请求进来，会耗尽内存，导致服务宕机

伪异步I/O的弊端分析
===>当对Socket的输入流进行读取操作的时候，它会一直阻塞下去，知道发生如下三件事情
（1）有数据可读
（2）可用数据已经读取完毕
（3）发生空指针或者I/O异常
===>这意味着当对方发送请求或应答消息比较缓慢，或者网络传输比较慢时候，读取输入流的一方的通信线程将被长时间阻塞。在阻塞期间，其他接入的消息只能在消息队列中排队。
===>伪异步I/O实际上仅仅只是对之前I/O线程模型的一个简单优化，它无法从根本上解决同步I/O导致的通信线程阻塞问题，下面我们简单分析下如果通信对方返回应答时间过长，会引起的级联鼓掌。
（1）服务端处理缓慢，返回应答消息耗费60s,平时只需要10ms
（2）采用伪异步I/O线程正在读取故障服务节点的响应，由于读取输入流是阻塞的。因此，它将会被同步阻塞60s
（3）假如所有的可用线程都被故障服务器阻塞，那后续所有的I/O消息都将在队列中排队。
（4）由于线程池采用阻塞队列实现，当队列积满之后，后续入队列的操作将被阻塞
（5）由于前端只有一个Accptor线程接收客户端接入，它被阻塞在线程池的同步阻塞队列之后，新的客户端请求消息将被拒绝，客户端会发生大量的连接超时。
（6）由于几乎所有的链接都超时，调用者会认为系统崩溃，无法接收新的请求消息。

【一】同步阻塞I/O服务端通信模型

第一：socket同步阻塞服务器的启动

package com.yeepay.sxf.testbio;

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

/**
 * 时间服务器
 * 基于同步阻塞I/O实现的服务器模型
 * @author sxf
 *
 */
public class TimerServer {
    
    /**
     * 启动timerServer服务器
     */
    public   void init(){
        int port=8000;
        //创建Socket服务
        ServerSocket server=null;
        try {
            server=new ServerSocket(port);
            System.out.println("TimerServer.init()===>the time server is start in port"+port);
            Socket socket=null;
            while(true){
                //获取一次socket请求
                socket=server.accept();
                //启动一个新线程处理socket请求
                new Thread(new TimerServerHandler(socket)).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(server!=null){
                try {
                    server.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            server=null;
        }
        
    }

    
    public static void main(String[] args) {
        //启动timerServer服务
        TimerServer timerServer=new TimerServer();
        timerServer.init();
    }
}

第二：soket服务器接收到请求的处理类

package com.yeepay.sxf.testbio;

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

/**
 * 时间服务器接受socket请求的处理类
 * @author sxf
 * 继承Runnable接口的线程类
 *
 */
public class TimerServerHandler implements Runnable {
    
    private Socket socket;

    public TimerServerHandler(Socket socket) {
        this.socket=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;
                }
                //打印请求信息
                System.out.println("TimerServerHandler.run()==>the time server receive order:"+body);
                
                //处理请求信息
                if("shangxiaofei".equals(body)){
                    currentTime=new Date(System.currentTimeMillis()).toString();
                }else{
                    currentTime="you is not get time";
                }
                //响应请求信息
                out.println(currentTime);
            }
            
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(in!=null){
                try {
                    in.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            
            if(out!=null){
                out.close();
            }
            
            if(this.socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            
            this.socket=null;
        }
        
        
        
        
    }

}

第三：向socket服务器发送请求

package com.yeepay.sxf.testbio;

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

/**
 * 创建一个客户端请求
 * @author sxf
 *
 */
public class TimerClient {
    
    
    
    public static void main(String[] args) {
        int port=8000;
        Socket socket=null;
        BufferedReader in=null;
        PrintWriter out=null;
        try {
            socket=new Socket("127.0.0.1",port);
            in=new BufferedReader(new InputStreamReader(socket.getInputStream()));
            out=new PrintWriter(socket.getOutputStream(),true);
            //发送请求
            out.println("shangxiaofei!=");
            System.out.println("TimerClient.main()send order to server success");
            
            //等待服务器响应
            String resp=in.readLine();
            System.out.println("TimerClient.main(Now is:)"+resp);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            if(out!=null){
                out.close();
                out=null;
            }
            if(in !=null){
                try {
                    in.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                in=null;
            }
            
            if(socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }

}

【二】同步阻塞I/O服务端通信模型构造的伪异步通信模型

一：伪异步socket服务端启动（就是在同步的基础上使用了线程池）

package com.yeepay.sxf.testbio;

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

/**
 * 时间服务器
 * 基于同步阻塞I/O实现的服务器模型
 * @author sxf
 *
 */
public class TimerServer {
    
    /**
     * 启动timerServer服务器
     */
    public   void init(){
        int port=8000;
        //创建Socket服务
        ServerSocket server=null;
        try {
            server=new ServerSocket(port);
            System.out.println("TimerServer.init()===>the time server is start in port"+port);
            Socket socket=null;
            //创建处理socket请求的线程池
            TimerServerHandlerExcetorPool pool=new TimerServerHandlerExcetorPool(50, 10000);
            
            while(true){
                //获取一次socket请求
                socket=server.accept();
                //将请求任务提交到线程池处理
                pool.execute(new TimerServerHandler(socket));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(server!=null){
                try {
                    server.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            server=null;
        }
        
    }

    
    public static void main(String[] args) {
        //启动timerServer服务
        TimerServer timerServer=new TimerServer();
        timerServer.init();
    }
}

二：伪异步socket服务处理socket请求的线程池

package com.yeepay.sxf.testbio;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
 * 处理socket服务器接收到的socket请求的线程池
 * @author sxf
 *
 */
public class TimerServerHandlerExcetorPool {

    private ExecutorService executorService;
    
    /**
     * 初始化线程池
     * @param maxPoolSize
     * @param queueSize
     */
    public TimerServerHandlerExcetorPool(int maxPoolSize,int queueSize){
        executorService=new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(), maxPoolSize, 120L, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(queueSize));
    }
    
    /**
     * 提交到线程池，执行socket请求任务
     * @param runnable
     */
    public void execute(Runnable runnable){
        executorService.execute(runnable);
    }
    
}

三：处理请求的Handler类（线程类）

package com.yeepay.sxf.testbio;

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

/**
 * 时间服务器接受socket请求的处理类
 * @author sxf
 * 继承Runnable接口的线程类
 *
 */
public class TimerServerHandler implements Runnable {
    
    private Socket socket;

    public TimerServerHandler(Socket socket) {
        this.socket=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;
                }
                //打印请求信息
                System.out.println("TimerServerHandler.run()==>the time server receive order:"+body);
                
                //处理请求信息
                if("shangxiaofei".equals(body)){
                    currentTime=new Date(System.currentTimeMillis()).toString();
                }else{
                    currentTime="you is not get time";
                }
                //响应请求信息
                out.println(currentTime);
            }
            
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(in!=null){
                try {
                    in.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            
            if(out!=null){
                out.close();
            }
            
            if(this.socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            
            this.socket=null;
        }
        
        
        
        
    }

}

四：客户端发送请求

package com.yeepay.sxf.testbio;

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

/**
 * 创建一个客户端请求
 * @author sxf
 *
 */
public class TimerClient {
    
    
    
    public static void main(String[] args) {
        int port=8000;
        Socket socket=null;
        BufferedReader in=null;
        PrintWriter out=null;
        try {
            socket=new Socket("127.0.0.1",port);
            in=new BufferedReader(new InputStreamReader(socket.getInputStream()));
            out=new PrintWriter(socket.getOutputStream(),true);
            //发送请求
            out.println("shangxiaofei!=");
            System.out.println("TimerClient.main()send order to server success");
            
            //等待服务器响应
            String resp=in.readLine();
            System.out.println("TimerClient.main(Now is:)"+resp);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            if(out!=null){
                out.close();
                out=null;
            }
            if(in !=null){
                try {
                    in.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                in=null;
            }
            
            if(socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }

}