码迷,mamicode.com
首页 > 其他好文 > 详细

IO模型之BIO代码详解及其优化演进

时间:2019-12-06 09:41:18      阅读:94      评论:0      收藏:0      [点我收藏+]

标签:ring   注释   queue   逻辑   local   高并发   handler   清理   执行命令   

一、BIO简介

  BIO是java1.4之前唯一的IO逻辑,在客户端通过socket向服务端传输数据,服务端监听端口。由于传统IO读数据的时候如果数据没有传达,IO会一直等待输入传入,所以当有请求过来的时候,新起一条线程对数据进行等待、处理,导致每一个链接都对应着服务器的一个线程。

  BIO是同步阻塞的,如图所示:

          技术图片

二、原理简述

  BIO对应linux io模型的阻塞IO,服务端提供IP和监听端口,客户端通过连接操作想服务端监听的地址发起连接请求,通过三次握手连接,如果连接成功建立,双方就可以通过套接字进行通信。

  重要组件
    ServerSocket:负责绑定IP地址,启动监听端口
    Socket:负责发起连接操作。连接成功后,双方通过输入和输出流进行同步阻塞式通信。

三、手写服务端

  首先我们来用ServerSocket和Socket写个服务端,并进行测试,代码以及注释如下:

public class BioServerSingle {  //blocking
    public static void main(String[] args) {
        // 服务端开启一个端口进行监听
        int port = 8080;
        ServerSocket serverSocket = null;   //服务端
        Socket socket;  //客户端
        InputStream in = null;
        OutputStream out = null;
        try {

            serverSocket = new ServerSocket(port);  //通过构造函数创建ServerSocket,指定监听端口,如果端口合法且空闲,服务器就会监听成功
            // 通过无限循环监听客户端连接,如果没有客户端接入,则会阻塞在accept操作
            while (true) {
                System.out.println("Waiting for a new Socket to establish" + " ," + new Date().toString());
                socket = serverSocket.accept();//阻塞  三次握手
                in = socket.getInputStream();
                byte[] buffer = new byte[1024];
                int length = 0;
                while ((length = in.read(buffer)) > 0) {//阻塞
                    System.out.println("input is:" + new String(buffer, 0, length) + " ," + new Date().toString());
                    out = socket.getOutputStream();
                    out.write("success".getBytes());
                    System.out.println("Server end" + " ," + new Date().toString());
                }

            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 必要的清理活动
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

  执行代码main方法启动服务端,并查看堆栈信息,可以看到服务端阻塞在ServerSocket的accept方法,如截图:

        技术图片

   此处即是ServerSocket的第一个阻塞点,接下来在控制台执行命令:

telnet localhost 8080

  打印此时堆栈信息可以看到ServerSocket阻塞在read方法,如截图所示:

        技术图片

  如果此时在控制台输入一些内容,那么服务端将接收到控制台输入,并会成功将服务端想要输出的的内容返回给控制台,如图所示:

        技术图片

   如图所示,这样就完成了一次socket的连接与数据传输,但是这样的Socket并未关闭,你仍旧可以继续在控制台输入内容,然后服务端接收输入,因为这一次的Socket并未关闭,从哪里可以看出来呢?

      技术图片

  如图所示:执行的代码并未重新等待一次新的Socket客户端请求,而且原先的Socket客户端(即控制台)仍旧可以继续同服务端进行输入输出交互,同时也可以打印堆栈信息进行确认,此时依旧阻塞在read方法而不是accept方法,此处不再截图。如果此时关闭客户端Socket(即控制台),那么此次Socket通信将结束,然后重新阻塞在Accept继续监听端口,等待新的客户端连接的到来。

  因此可以确认ServerSocket两个阻塞点,分别是accept、read,accept阻塞等待新的socket通信建立请求,read阻塞等待客户端输入。

四、手写客户端

public class BioClient {

    public static void main(String[] args) {
        Socket clientSocket = null;
        OutputStream outputStream = null;
        InputStream inputStream  = null;
        try{
            // 新建一个Socket请求
            clientSocket = new Socket("localhost",8080);
            System.out.println("Build the connection successfully!"+" ,"+new Date().toString());
            outputStream = clientSocket.getOutputStream();
            inputStream = clientSocket.getInputStream();
            byte[] buffer = new byte[1024];
            Scanner scanner = new Scanner(System.in);
            while(true){
                System.out.println("Please input a String !"+" ,"+new Date().toString());
                String string = scanner.nextLine();
                if("end".equals(string)){
                    System.out.println("Client end"+" ,"+new Date().toString());
                    break;
                }
                outputStream.write(("This is a new request: "+string).getBytes());
                int length = 0;
                if ((length = inputStream.read(buffer)) > 0) {//阻塞
                }
                System.out.println("The response is:" + new String(buffer, 0, length)+" ,"+new Date().toString());
            }

        }catch (Exception e){

        } finally {
            if (clientSocket != null) {
                try {
                    clientSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

  启动main方法,如下截图(客户端和服务端):

          技术图片

          技术图片 

  客户端可以一直接受请求,直到输入end结束此次客户端输入,那么服务端能一直接受请求,然后给出答复,当客户端断开请求后,服务端重新恢复监听,等待新的socket请求的到来。

  因此,在BIO通信模型中,Socket通信的发起以及结束都是客户端进行的。

五、多Socket客户端请求处理

  上面进行的是1对1的Socket通信建立,如果已经有一个Socket请求在处理的时候,此时再来一个socket请求,那么会怎样呢,我们通过两个控制台简历请求进行测试。

        技术图片 

   如截图所示,客户端1和客户端建立Socket请求的通信并未报错,客户端①可以正常通信,但是客户端②的请求并未得到响应。

  我们因此可以知道BIO是一对一应答模型,一个Socekt只能支持一个通信,如果一个客户端没有断开,当前线程会阻塞在读操作。要想实现同时处理多个通信,那么就必须建立多个Socket,因此此时服务端可以通过多线程,在socket请求到来时,单独为通信建立一个Socket进行通信,代码如下:

public class BioServerThread {
    public static void main(String[] args) {
        int port=8080;
        ServerSocket serverSocket=null;
        try{

            serverSocket=new ServerSocket(port);
            Socket socket=null;
            while (true){
                socket=serverSocket.accept();//拿到socket
                //连接量大的时候 会拖垮cpu
                new Thread(new SocketHandler(socket)).start();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (serverSocket!=null){
                try {
                    serverSocket.close();
                    serverSocket=null;
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }
}
public class SocketHandler implements Runnable {
    private Socket socket;

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

    public void run() {
        InputStream in = null;
        OutputStream out = null;
        try {
            in = socket.getInputStream();
            byte[] buffer = new byte[1024];
            int length = 0;
            while ((length = in.read(buffer)) > 0) {//阻塞
                System.out.println("input is:" + new String(buffer, 0, length));
                out = socket.getOutputStream();
                out.write("success".getBytes());
                System.out.println("end");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (out != null) {
                try {
                    out.close();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
            if (socket!=null){
                try {
                    socket.close();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    }
}

  此时用两个控制台建立两个socket请求进行测试:

          技术图片

  如图所示,客户端①和客户端②同时得到了服务端的返回,服务端成功完成了多请求的处理。

六、线程池管理Socket

  虽然为了解决该问题可以引入多线程,实现伪异步IO,但是因为处理线程和客户端是1:1的关系,随着客户端请求增大,线程数随着上升,会极大的消耗cpu资源,引起服务器异常。为了保障服务器资源可以实现线程池,如果发生读取数据较慢时,大量并发的情况下,其他接入的客户都只能一直等待。

  代码如下:

public class ServerHandlerExcutePool {
    private ExecutorService executor;

    public ServerHandlerExcutePool(int maxPoolSize, int queueSize){
        executor=new ThreadPoolExecutor(2, maxPoolSize, 120L, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(queueSize));
    }

    public void execute(Runnable task){
        executor.execute(task);
    }
}
public class BioServerThreadPool {
    public static void main(String[] args) {
        int port=8080;
        ServerSocket serverSocket=null;
        try{
            //1000000
            serverSocket=new ServerSocket(port);
            Socket socket=null;
            //100000    100000
            ServerHandlerExcutePool excutePool=new ServerHandlerExcutePool(2,100);
            while (true){
                socket=serverSocket.accept();
                excutePool.execute(new SocketHandler(socket));
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (serverSocket!=null){
                try {
                    serverSocket.close();
                    serverSocket=null;
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }
}

  如截图所示,我设置线程池最多处理两个请求,那么此时第三个客户端的连接依旧无法处理,这样避免了创建大量的线程创建新的Socket,多余线程池大容量的请求只能阻塞。

        技术图片

   综上所述,BIO的特点是缺乏弹性伸缩能力,在高并发这种大量请求来临时,并不具备强大的处理能力。

IO模型之BIO代码详解及其优化演进

标签:ring   注释   queue   逻辑   local   高并发   handler   清理   执行命令   

原文地址:https://www.cnblogs.com/jing99/p/11993041.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!