Netty学习-伪异步BIO

超、凢脫俗 2021-11-06 00:20 387阅读 0赞

上一节我们讲了最最传统的BIO，该BIO十分浪费资源，因为其一对一线程的特性。  
于是出现了伪异步的I/O编程

伪异步的I/O模型采用线程池和任务队列。当由新的客户端接入时，降客户端的Socket封装成一个Task投递到后端的线程池中进行处理，JDK的线程池维护一个消息队列和N个活跃线程，对消息队列中的任务进行处理。线程池可以设置消息队列的大小和最大线程数。

对上一节中的BIO代码进行改进

package BIO2;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintWriter;
    import java.net.Socket;
    
    /**
     * @author 陈晨
     * @date 2019/8/8
     * @Description 类描述
     */
    public class TimeClient {
        public static void main(String[] args) throws IOException {
            int port=8080;
            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("TIME ORDER");
                System.out.println("Send order2server succeed");
                String resp = in.readLine();
                System.out.println(resp);
            }catch (Exception e){
    
            }
            finally {
                if(out!=null){
                    out.close();
                    out=null;
                }
                if (in!=null){
               try {
                   in.close();
               }catch (IOException e){
                   e.printStackTrace();
               }
               in=null;
                }
                if(socket!=null){
                    try{
                        socket.close();
                    }catch (IOException e)
                    {
                        e.printStackTrace();
                    }
                    socket=null;
                }
    
            }
            }
    
    }

package BIO2;
    
    import java.io.IOException;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    /**
     * @author 陈晨
     * @date 2019/8/8
     * @Description 类描述
     */
    //伪异步
    public class TimeServer {
        public static void main(String[] args) throws IOException {
            int port=8080;
            ServerSocket server=null;
            try {
                server=new ServerSocket(port);
                System.out.println("port:"+8080);
                Socket socket=null;
                TimeServerHandlerExecutePool singleExexutor =new TimeServerHandlerExecutePool(50,10000);
                while(true){
                    socket=server.accept();
                    singleExexutor.execute(new TimeServerHandler(socket));
                }
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                if(server!=null){
                    System.out.println("close");
                    server.close();
                    server=null;
                }
            }
        }
    }

package BIO2;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintWriter;
    import java.net.Socket;
    
    /**
     * @author 陈晨
     * @date 2019/8/8
     * @Description 类描述
     */
    public class TimeServerHandler implements Runnable {
        private Socket socket;
    
        public TimeServerHandler(Socket socket) {
        this.socket=socket;
        }
        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("receive"+body);
                    currentTime="QUERY TIME ORDER".equalsIgnoreCase(body)?new java.util.Date(System.currentTimeMillis())
                            .toString(): "BAD ORDER" ;
                    out.println(currentTime);
                }
            } catch (IOException e) {
                e.printStackTrace();
                if(in!=null){
                    try{
                        in.close();
                    }catch (IOException e1){
                        e1.printStackTrace();
                    }
                }
                if (out!=null){
                    out.close();
                    out=null;
                }
                if(this.socket!=null){
                    try{
                        this.socket.close();
                    }catch (IOException e1){
                        e1.printStackTrace();
                    }
                    this.socket=null;
                }
            }
        }
    }

package BIO2;
    
    import java.util.concurrent.*;
    
    /**
     * @author 陈晨
     * @date 2019/8/8
     * @Description 类描述
     */
    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(java.lang.Runnable task){
            executor.execute(task);
        }
    }

伪异步I/O通信框架采用线程池实现，因此避免了伪每个请求都创建一个独立线程造成的资源小号问题，但是由于它底层的通信任然采用同步阻塞模型，因此无法从根本上解决问题。

《Netty权威指南》