【Java】BIO，NIO，AIO聊天室示例

已于 2022-09-12 10:09:32 修改
阅读量297 收藏
点赞数
分类专栏： 学习时候记录的笔记 文章标签： java nio 服务器
于 2022-09-04 20:36:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41279172/article/details/126693984
版权

BIO，NIO，AIO聊天室示例

几个概念

  • 同步： 发送方发送请求之后，需要等接收方发回响应后才接着发
  • 异步： 发送方发送请求之后，不等待接收方响应，继续发送下一个，系统内核完成请求后主动通知
  • 阻塞： 在调用结果返回之前，当前线程会被挂起，需等到得到结果后才会返回。线程在此过程中不进行任何其他处理。
  • 非阻塞： 调用结果不会立即返回，当前线程也不会被挂起，而是立即返回执行下一个调用。

socket连接


连接过程:

服务器端:

  1. 创建socket，绑定端口
  2. 开始监听
  3. 等待并接收客户端连接请求，返回新socket
  4. 由新socket与客户端进行交互
  5. 关闭连接

客户端：

  1. 创建socket
  2. 连接服务器与io交互
  3. 关闭连接

示例代码:

服务器端:

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public class ChatServer {

    /**
     * 监听端口号
     */
    private int port = 8081;

    public ChatServer() {
    }

    public ChatServer(int port) {
        this.port = port;
    }

    public void service() {
        try {
            System.out.println("服务器开始建立连接");
            // 建立服务器连接
            ServerSocket serverSocket = new ServerSocket(port);
            System.out.println("服务器开始监听");
            // 开始监听
            Socket socket = serverSocket.accept();
            // 获取输出流,向客户端发送信息
            OutputStream outputStream = socket.getOutputStream();
            BufferedReader reader = null;
            try {
                // 获取输入流,读取客户端传过来的信息
                reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                String line = "";
                while ((line = reader.readLine()) != null) {
                    System.out.println("从客户端接收到一条消息,内容为:" + line);
                }
                // 发送消息给客户端
                outputStream.write("我接收到了".getBytes(StandardCharsets.UTF_8));
            } finally {
                // 关闭流和连接
                if(reader != null) {
                    reader.close();
                }
                if(outputStream != null) {
                    outputStream.close();
                }
                if(socket != null) {
                    socket.close();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        ChatServer chatServer = new ChatServer();
        chatServer.service();
    }
}

客户端:

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public class ChatClient {

    private int port = 8080;

    public ChatClient() {
    }

    public ChatClient(int port) {
        this.port = port;
    }

    private void consumer() {
        System.out.println("客户端开始发送数据");
        try {
            Socket client = new Socket("localhost", 8081);
            OutputStream outputStream = client.getOutputStream();
            try {
                outputStream.write("这里是8080端口".getBytes(StandardCharsets.UTF_8));
            } finally {
                if(outputStream != null) {
                    outputStream.close();
                }
                if(client != null) {
                    client.close();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        ChatClient client = new ChatClient();
        client.consumer();
    }
}

运行结果:
在这里插入图片描述

在这里插入图片描述

BIO（同步阻塞IO模式）

每一个客户端的请求都需要服务端开启一个线程处理。

package com.alone.study.chat.bio;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;

import static java.util.concurrent.Executors.newFixedThreadPool;

public class ChatServer {

    /**
     * 监听端口号
     */
    private int port = 8081;
    /**
     * 处理socket的线程池
     */
    private static final ExecutorService EXECUTOR_SERVICE = newFixedThreadPool(10);
    private List<Socket> sockets = new ArrayList<>(10);

    public ChatServer() {
    }

    public ChatServer(int port) {
        this.port = port;
    }

    public void service() {
        try {
            System.out.println("服务器开始建立连接");
            // 建立服务器连接
            ServerSocket serverSocket = new ServerSocket(port);
            System.out.println("服务器开始监听");
            // 开始监听
            Socket socket = serverSocket.accept();
            sockets.add(socket);
            EXECUTOR_SERVICE.submit(new SocketThread(socket));
            Thread.sleep(2000);
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        } finally {
            if(sockets != null) {
                for (Socket socket : sockets) {
                    if(socket != null) {
                        try {
                            socket.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }

    public static void main(String[] args) {
        ChatServer chatServer = new ChatServer();
        chatServer.service();
    }

    private class SocketThread implements Runnable {

        private Socket socket;

        public SocketThread() {
        }

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

        @Override
        public void run() {
            System.out.println("开始处理来自" + socket.getRemoteSocketAddress() + "的请求");
            // 接收客户端的消息
            readFromClient();
            // 回复客户端说已收到
            sendToClient();
        }

        private void sendToClient() {
            OutputStream outputStream = null;
            // 回复客户端
            try {
                outputStream = socket.getOutputStream();
                // 发送消息给客户端
                outputStream.write("我接收到了".getBytes(StandardCharsets.UTF_8));
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                // 关闭流和连接
                if(outputStream != null) {
                    try {
                        outputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        private void readFromClient() {
            // 接收客户端的数据
            BufferedReader reader = null;
            try {
                System.out.println("开始获取客户端接收的消息");
                // 获取输入流,读取客户端传过来的信息
                reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                String line = "";
                while ((line = reader.readLine()) != null) {
                    System.out.println("从客户端接收到一条消息,内容为:" + line);
                }
                System.out.println("结束获取客户端接收的消息");
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                // 关闭流和连接
                if(reader != null) {
                    try {
                        reader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

}


package com.alone.study.chat.bio;

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.ExecutorService;

import static java.util.concurrent.Executors.newFixedThreadPool;

public class ChatClient {

    private int port = 8080;
    private static final ExecutorService EXECUTOR_SERVICE = newFixedThreadPool(1);

    public ChatClient() {
    }

    public ChatClient(int port) {
        this.port = port;
    }

    private void consumer() {
        System.out.println("客户端开始发送数据");
        try {
            Socket client = new Socket("localhost", 8081);
            OutputStream outputStream = client.getOutputStream();
            try {
                outputStream.write("这里是8080端口".getBytes(StandardCharsets.UTF_8));
                System.out.println("客户端结束发送数据");
            } finally {
                if(outputStream != null) {
                    outputStream.close();
                }
                if(client != null) {
                    client.close();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        ChatClient client = new ChatClient();
        client.consumer();
    }
}

不太理解上面这个服务端为啥会报错。

NIO

nio学习笔记

to be continue…

参考资料

1.java的socket连接，聊天室通信实现
2. 简述Socket连接的过程
3. Java网络编程之通过代码实现Socket通信
4. BIO、NIO、AIO实现聊天室功能
5. 同步、异步、阻塞、非阻塞傻傻分不清？

wannatolive
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
AIO高并发服务器、客户端聊天室源码
04-15
I/O 与 NIO 一个比较重要的区别是我们使用 I/O 的时候往往会引入多线程，每个连接使用一个单独的线程，而 NIO 则是使用单线程或者只使用少量的多线程，每个连接共用一个线程。而由于 NIO 的非阻塞需要一直轮询，比较消耗系统资源，所以异步非阻塞模式 AIO 就诞生了。 AIO高并发服务器、客户端聊天室源码奉献。
java BIO NIO AIO
07-18
Java BIO NIO AIO Java BIO、NIO、AIO是 Java 中的三种 I/O 模式，每种模式都有其特点和应用场景。下面对每种模式进行详细解释。 Java BIO Java BIO（ Blocking I/O）是一种同步阻塞式的 I/O 模式，即服务器实现...
Java系列技术之网络编程与NIO、AIO进阶
12-19
<img src="https://img-bss.csdn.net/201912191430278668.png" alt="" />
Java聊天室——从0开始打造基于netty的100w级高并发应用
架构师尼恩
11-22 3345
Netty聊天室 疯狂创客圈 Java 分布式聊天室【 亿级流量】实战系列之18 【 博客园 总入口】 QQ群：104131248 】 文章目录Netty聊天室源码工程写在前面【百万级流量 聊天室实战】：【分布式 聊天室】【Spring +Netty】：【Netty 原理】 死磕 系列【提升篇】：【内力大增篇】：疯狂创客圈 Java 死磕系列 源码工程 源码IDEA工程获取链接：Java ...
Java NIO实战之聊天室功能详解
08-25
Java NIO实战之聊天室功能详解 Java NIO实战之聊天室功能详解主要介绍了Java NIO实战之聊天...Java NIO实战之聊天室功能详解为开发者提供了一个很好的Java NIO实战示例，能够帮助开发者更好地理解和掌握Java NIO技术。
基于java的BIO、NIO、AIO通讯模型代码实现
03-24
Java作为一门广泛使用的开发语言，提供了多种I/O（Input/Output）通信模型，包括传统的阻塞I/O（BIO）、非阻塞I/O（NIO）以及异步I/O（AIO）。这些通信模型在不同的场景下有着各自的优势，理解和掌握它们对于优化...
bio nio aio demo
04-11
为了处理与外部世界的交互，Java提供了三种不同的I/O模型：BIO（ Blocking I/O）、NIO（Non-blocking I/O）和AIO（Asynchronous I/O）。这些模型各有优缺点，适用于不同场景。下面我们将深入探讨这三种I/O模型，并...
Java中BIO、NIO、AIO的理解
08-28
"Java中BIO、NIO、AIO的理解" Java中BIO、NIO、AIO的理解是Java高性能IO体系设计中三个重要的概念。它们都是Java中IO操作的实现方式，但它们之间有着很大的区别。 首先，我们需要了解什么是同步和异步，什么是阻塞...
详解Java 网络IO编程总结（BIO、NIO、AIO均含完整实例代码）
08-28
本篇文章主要介绍了Java 网络IO编程总结（BIO、NIO、AIO均含完整实例代码），具有一定的参考价值，感兴趣的小伙伴们可以参考一下
java aio 编程
qq_26847293的博客
03-23 359
Java NIO (JSR 51)定义了Java new I/O API，提案2000年提出,2002年正式发布。 JDK 1.4起包含了相应的API实现。 JAVA NIO2 (JSR 203)定义了更多的 New I/O APIs， 提案2003提出，直到2011年才发布， 最终在JDK 7中才实现。 JSR 203除了提供更多的文件系统操作API(包括可插拔的自定义的文件系统)， 还提供了
java AIO 服务端代码实现
暮鼓的博客
07-14 3801
java 7引入AIO  基于linux epoll， window iocp异步 I/O（简称 AIO）AIO 的核心概念：发起非阻塞方式的 I/O 操作。当 I/O 操作完成时通知。应用程序的责任就是：什么时候发起操作？ I/O 操作完成时通知谁？AIO 的 I/O 操作，有两种方式的 API 可以进行：Future 方式  和 Callback 方式。Future 方式：即提交一个 I/O ...
java socket编程之聊天室（三）
anitak的专栏
12-08 629
使用 ServerSocket 建立聊天服务器
Java AIO总结与示例
热门推荐
x_i_y_u_e的专栏
08-16 1万+
AIO是异步IO的缩写，虽然NIO在网络操作中，提供了非阻塞的方法，但是NIO的IO行为还是同步的。对于NIO来说，我们的业务线程是在IO操作准备好时，得到通知，接着就由这个线程自行进行IO操作，IO操作本身是同步的。 但是对AIO来说，则更加进了一步，它不是在IO准备好时再通知线程，而是在IO操作已经完成后，再给线程发出通知。因此AIO是不会阻塞的，此时我们的业务逻辑将变成一个回调函数，等待I
Java实现的聊天室
QLH的博客
05-10 2435
单线程聊天室： 聊天室是客户端与服务器组成，下图可以清楚理解的它们之间的关系： 一.服务器 1.创建服务器（建立ServerSocket） 2.等待客户端连接 3.接收数据与发送数据 3.1服务器接受客户端发送的信息 3.2从服务器发送信息到客户端 注意：服务端先接受信息时，客户端必须是先发送信息，更不能同时发送与接收，因为是单线程 二.客户端 1.创建客户端 2.连接服务器端 3.发送数据与...
基于 AIO 实现非阻塞的聊天室
Coder_xh的博客
03-10 441
复习 AIO 写的小 Demo 涉及到两个核心类：1. AsynchronousServerSocketChannel 2. AsynchronousSocketChannel 服务端 public class SimpleAIOServer { static final int PORT = 30000; public static vo...
基于AIO的聊天室
ja_ge_va的博客
01-05 331
/** * 简介： * java 7 的NIO.2提供了一步Channel支持，这种异步的Channel可以提供更高效的IO, * 这种基于异步的Channel的IO机制也被称为异步IO(AsynchronousIO) * 几种IO流的区别： * 按照POSIX的标准来划分IO,可以把IO分为两类：同步IO和异步IO。对于IO操作可以分为两步： * 1.程序发出IO请求 * 2.完...
基于AIO的CS聊天室
五山口老法师
11-20 385
所谓AIO，即是异步IO，它的IO操作交由操作系统完成。设置监听器（类似于一个信号处理函数），当系统IO操作完成时，会被监听器监听到，并执行相应的后续操作，然后返回。 监听器一般使用CompletionHandler。 服务器端代码：  package com.nanhao.AIOTest; import java.io.IOException; import java.net.Inet...
Java网络面试必备：BIO、NIO、AIO与Netty详解
Java网络通信面试中，常常会涉及到BIO（Blocking I/O）、NIO（Non-blocking I/O）、AIO（Asynchronous I/O）以及Netty这几个概念。它们是Java中处理网络通信的不同方式，理解它们有助于提升网络编程的效率和性能。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值