1-1 阻塞、伪异步I/O demo与对比

最新推荐文章于 2023-06-10 20:48:26 发布

H_crab

最新推荐文章于 2023-06-10 20:48:26 发布

阅读量241

点赞数

CC 4.0 BY-SA版权

分类专栏： Netty

本文链接：https://blog.youkuaiyun.com/H_crab/article/details/96439935

Netty 专栏收录该内容

5 篇文章

订阅专栏

本文详细介绍了传统的阻塞I/O模型及其Java实现案例，并进一步探讨了伪异步I/O的概念，通过引入线程池和阻塞队列改进服务器处理效率的方法。通过对两种模型的对比分析，帮助读者理解不同I/O模型的特点。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、阻塞I/O

阻塞I/O即为最传统的I/O,Server端需要停的Accept()，去轮训接受sokect里的消息,占用资源

练习：先启动Server端,后启动Clinet端

Client.java

import java.io.*;
import java.net.Socket;

public class Client {
    public static void main (String ... argas){
        BufferedReader in = null;
        PrintWriter out = null;
        Socket socket = null;
        try {
            socket = new Socket("127.0.0.1",9091);
            InputStream inputStream = socket.getInputStream();
            InputStreamReader reader = new InputStreamReader(inputStream);
            out = new PrintWriter(socket.getOutputStream(),true);
            out.println("我是客户端");
            System.out.println("向客户端发送消息");

            in = new BufferedReader(reader);
            System.out.println(in.readLine());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(null !=in){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            };
            }
        }
    }

Server.java

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

public class Server {
    public static void main (String ... args ){
        ServerSocket serverSocket = null;
        Socket socket= null;
        try {
            serverSocket = new ServerSocket(9091);
            while (true){
                socket = serverSocket.accept();
                System.out.println("客户端来连接了");
                new Thread(new ServerHandle(socket)).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(null!=socket){
                System.out.println("处理完毕");
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

ServerHandler,java

import java.io.*;
import java.net.Socket;

public class ServerHandle  implements Runnable{
    Socket socket;

    public ServerHandle(Socket accept){
        this.socket=accept;
    }

    public void run() {
        BufferedReader in = null;
        PrintWriter out = null;
        try {
            InputStream inputStream=socket.getInputStream();
            InputStreamReader reader = new InputStreamReader(inputStream);
            in = new BufferedReader(reader);
            out = new PrintWriter(socket.getOutputStream(),true);
            while(true){
                String body = in.readLine();
                if(null==body){
                    break;
                }
                System.out.println("接收到服务器发来的消息："+body);
                out.println("服务器收到了");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(null !=in){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if(null!=out){
                    out.close();
                }
            }
        }
    }
}

2、伪异步I/O

BlockingQueue接口及其实现类讲解

https://blog.youkuaiyun.com/Howinfun/article/details/80744004

Server.java

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

public class Server {
    public static void main (String ... args ){
        ServerSocket serverSocket = null;
        Socket socket= null;
        try {
            serverSocket = new ServerSocket(9091);
            while (true){
                socket = serverSocket.accept();
                System.out.println("客户端来连接了");
                //变化 通过ThreadPoolServer创建一个线程池通过有界队列处理
                ThreadPoolServer threadPoolServer = new ThreadPoolServer(3,5,3); 
                threadPoolServer.execute(new ServerHandle(socket));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(null!=socket){
                System.out.println("处理完毕");
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

ThreadPoolServer.java

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

public class ThreadPoolServer {
    ExecutorService executorService = null;

    public ThreadPoolServer(int corePoolSize,int maxinumPoolSize,int queueSize){
        executorService = new ThreadPoolExecutor(corePoolSize,maxinumPoolSize,
                100L,TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(queueSize));

    }

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

ServerHandler,java --与上面无变化

阻塞I/O 与伪异步I/O对比