【Java网络编程】基于BIO/NIO/AIO的多人聊天室（五）：AIO聊天室

最新推荐文章于 2024-06-30 18:10:26 发布
最新推荐文章于 2024-06-30 18:10:26 发布
阅读量367 收藏 5
点赞数
分类专栏： 网络编程 文章标签： 网络 java socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NoxUni/article/details/109444269
版权

课程《一站式学习Java网络编程 全面理解BIO/NIO/AIO》的学习笔记（五）：
异步调用机制 & AIO编程模型 & 基于AIO的多人聊天室实现

源码地址：https://github.com/NoxWang/web-program

【Java网络编程】基于BIO/NIO/AIO的多人聊天室（一）：java IO与内核IO
【Java网络编程】基于BIO/NIO/AIO的多人聊天室（二）：BIO聊天室
【Java网络编程】基于BIO/NIO/AIO的多人聊天室（三）：NIO概述与实践
【Java网络编程】基于BIO/NIO/AIO的多人聊天室（四）：NIO聊天室
【Java网络编程】基于BIO/NIO/AIO的多人聊天室（六）：思维导图

一、异步调用机制

1.1 AIO中的异步操作

  • AsynchronousSocketChannel：客户端Socket通道
  • AsynchronousServerSocketChannel：服务端Socket通道
  • connect / accept：建立连接（支持异步操作）
  • read / write：读写操作（支持异步操作）
    AIO异步操作

1.2 异步调用机制

1.2.1 Future

Channel异步调用connect / accept，read / write等方法，方法返回一个Future对象。获得Future对象后，我们可以对它进行如下操作：

  • 调用Future的get()方法：该方法是阻塞式调用，它会一直阻塞，直到Future所对应的任务完成并返回。
  • 调用Future的isDone()方法：再一个循环中调用该方法，不停询问任务是否已完成，可设置超时时间。

1.2.2 CompletionHandler

Channel异步调用connect / accept，read / write等方法时，将一个CompletionHandler作为参数传入。

CompletionHandler是一个接口，它提供两个回调函数（callback），completed()和failed()，我们可以自己实现这两个方法。当异步操作完成后，系统会调用回调函数（操作成功则调用completed()，发生异常则调用failed()），完成相关业务功能。

二、AIO编程模型

2.1 AsynchronousChannelGroup

我们使用的异步通道属于一个AsynchronousChannelGroup，即异步通道组，是一组可以被多个异步通道共享的资源群组。Group可以自定义，如果不特别指定，系统会使用默认群组。

需要ChannelGroup的原因：AIO机制下，操作系统帮我们做了很多事，比如当调用完成时，操作系统会自动回调函数。操作系统完成这些功能需要一定的系统资源，比如线程池。Group中会包含线程池等资源，操作系统可以复用线程池中的线程来实现回调函数等功能。

2.2 异步实现

  1. 创建AsynchronousServerSocketChannel后，需要创建一个AcceptHandler，用于处理accept()的异步调用，Client1连接后，会触发该Handler；
  2. AcceptHandler会获得连接后返回的AsynrounousSocketChannel。服务端Channel需要进行读写操作，这些操作也是异步调用的，因此需要再创建一个ClientHandler用于处理客户端的读写调用；
  3. 每当有新客户端连接，都会再次触发AcceptHandler，完成相应操作（即为新的客户端Channel注册一个ClientHandler）
  4. 当某个客户端有IO操作，会触发对应的ClientHandler，完成特定的业务操作
    AIO调用机制

三、基于AIO的多人聊天室实现

3.1 服务端

在服务端，我们使用CompletionHandler来实现异步调用

package server;

import java.io.Closeable;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.AsynchronousChannelGroup;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ChatServer {

    private static final String LOCALHOST = "localhost";
    private static final int DEFAULT_PORT = 8888;
    private int port;

    private static final int BUFFER_SIZE = 1024;
    private static final int THREADPOOL_SIZE = 8;

    private static final String QUIT = "\\quit";
    private Charset charset = Charset.forName("UTF-8");

    private AsynchronousChannelGroup channelGroup;
    private AsynchronousServerSocketChannel serverChannel;

    private List<ClientHandler> connectedClients;

    public ChatServer() {
        this(DEFAULT_PORT);
    }

    public ChatServer(int port) {
        this.port = port;
        this.connectedClients = new ArrayList<>();
    }

    private boolean readyToQuit(String msg) {
        return QUIT.equals(msg);
    }

    private void close(Closeable closeable) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 服务端主逻辑
     */
    private void start() {
        try {
            // 创建线程池
            ExecutorService executorService = Executors.newFixedThreadPool(THREADPOOL_SIZE);
            // 创建自定义线程池的ChannelGroup
            channelGroup = AsynchronousChannelGroup.withThreadPool(executorService);
            // 创建自定义ChannelGroup的异步服务端Channel
            serverChannel = AsynchronousServerSocketChannel.open(channelGroup);

            serverChannel.bind(new InetSocketAddress(LOCALHOST, port));
            System.out.println("启动服务器，监听端口: " + port + "...");

            while (true) {
                serverChannel.accept(null, new AcceptHandler());
                System.in.read();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            close(serverChannel);
        }
    }

    private class AcceptHandler implements CompletionHandler<AsynchronousSocketChannel, Object> {
        @Override
        public void completed(AsynchronousSocketChannel clientChannel, Object attachment) {
            // 服务端持续监听客户端请求
            if (serverChannel.isOpen()) {
                serverChannel.accept(null, this);
            }

            if (clientChannel != null && clientChannel.isOpen()) {
                ClientHandler handler = new ClientHandler(clientChannel);

                // 添加用户至在线列表
                addClient(handler);

                ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
                clientChannel.read(buffer, buffer, handler);
            }
        }

        @Override
        public void failed(Throwable exc, Object attachment) {
            System.out.println("连接失败: " + exc);
        }
    }

    private synchronized void addClient(ClientHandler handler) {
        connectedClients.add(handler);
        System.out.println(getClientName(handler.clientChannel) + "已连接");
    }

    private synchronized void removeClient(ClientHandler handler) {
        connectedClients.remove(handler);
        System.out.println(getClientName(handler.clientChannel) + "已断开");
        close(handler.clientChannel);
    }

    private class ClientHandler implements CompletionHandler<Integer, Object> {

        AsynchronousSocketChannel clientChannel;

        public ClientHandler (AsynchronousSocketChannel channel) {
            this.clientChannel = channel;
        }
        @Override
        public void completed(Integer result, Object attachment) {
            ByteBuffer buffer = (ByteBuffer) attachment;
            if (buffer != null) {   // 说明此时需要处理的是读
                if (result <= 0) {
                    // 客户端异常，移出在线列表
                    removeClient(this);
                } else {
                    // 获取并打印客户端发送来的信息
                    buffer.flip();
                    String fwdMsg = receive(buffer);

                    // 用户准备退出
                    if (readyToQuit(fwdMsg)) {
                        removeClient(this);
                        return;
                    }

                    System.out.println(getClientName(clientChannel) + ": " + fwdMsg);

                    // 给其他客户端发送消息
                    forwardMessage(clientChannel, fwdMsg);
                    buffer.clear();

                    // 持续监听该客户端channel的输入
                    clientChannel.read(buffer, buffer, this);
                }
            }
        }

        @Override
        public void failed(Throwable exc, Object attachment) {
            System.out.println("读写失败：" + exc);
        }
    }

    private synchronized void forwardMessage(AsynchronousSocketChannel clientChannel, String fwdMsg) {
        for (ClientHandler handler : connectedClients) {
            if (!clientChannel.equals(handler.clientChannel)) {
                try {
                    ByteBuffer buffer = charset.encode(getClientName(clientChannel) + ": " + fwdMsg);
                    handler.clientChannel.write(buffer, null, handler);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private String getClientName(AsynchronousSocketChannel clientChannel) {
        int clientPort = -1;
        try {
            InetSocketAddress address = (InetSocketAddress) clientChannel.getRemoteAddress();
            clientPort = address.getPort();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return "客户端[" + clientPort + "]";
    }

    private String receive(ByteBuffer buffer) {
        CharBuffer charBuffer = charset.decode(buffer);
        return String.valueOf(charBuffer);
    }

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

3.2 客户端

在客户端，我们使用Future来实现异步调用

ChatClient.java

package client;

import java.io.Closeable;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.charset.Charset;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class ChatClient {

    private static final String LOCALHOST = "localhost";
    private String host;
    private static final int DEFAULT_PORT = 8888;
    private int port;

    private static final int BUFFER_SIZE = 1024;

    private static final String QUIT = "\\quit";
    private Charset charset = Charset.forName("UTF-8");

    private AsynchronousSocketChannel clientChannel;

    public ChatClient() {
        this(LOCALHOST, DEFAULT_PORT);
    }

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

    public boolean readyToQuit(String msg) {
        return QUIT.equals(msg);
    }

    public void close(Closeable closeable) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public void start() {
        try {
            // 创建客户端channel
            clientChannel = AsynchronousSocketChannel.open();
            // 连接服务端，异步调用
            Future<Void> future = clientChannel.connect(new InetSocketAddress(host, port));
            future.get();

            // 处理用户输入
            new Thread(new UserInputHandler(this)).start();

            ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
            while (true) {
                Future<Integer> readResult = clientChannel.read(buffer);
                int result = readResult.get();

                if (result <= 0) {
                    // 说明出现异常，无法再从服务器得到有效信息
                    System.out.println("服务器断开");
                    close(clientChannel);
                    System.exit(1);

                } else {
                    buffer.flip();
                    String msg = String.valueOf(charset.decode(buffer));
                    buffer.clear();
                    System.out.println(msg);
                }
            }

        } catch (IOException | InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }

    public void send(String msg) {
        if (msg.isEmpty()) {
            return;
        }

        ByteBuffer buffer = charset.encode(msg);
        Future<Integer> writeResult = clientChannel.write(buffer);
        try {
            writeResult.get();
        } catch (InterruptedException | ExecutionException e) {
            System.out.println("发送消息失败");
            e.printStackTrace();
        }
    }

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

UserInputHandler.java

package client;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class UserInputHandler implements Runnable {

    private ChatClient chatClient;

    public UserInputHandler (ChatClient client) {
        this.chatClient = client;
    }

    @Override
    public void run() {
        try {
            BufferedReader consoleReader = new BufferedReader(
                    new InputStreamReader(System.in)
            );
            String msg = null;
            while ((msg = consoleReader.readLine()) != null) {
                chatClient.send(msg);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
流心芝士挞
关注
专栏目录
一站式学习Java网络编程 全面理解BIO_NIO_AIO，学习手记（六）
好想去看海
09-30 636
文章目录1. NIO模型分析2.聊天室项目代码重点知识2.1 服务器端2.1.1 字段2.1.2 主方法2.1.3 处理方法2.1.4 转发消息方法2.1.5 接收消息方法2.2 客户端2.2.1 字段2.2.2 主方法2.2.3 处理方法2.2.4 接收方法2.2.5 发送方法3. 测试结果4. 完整代码4.1 服务器端4.2 客户端4.3 客户端监听用户输入进程 1. NIO模型分析 在服务器端创建一个Selector，将ServerSocketChannel注册到Selector上，被Selec
手动搭建I/O网络通信框架3：NIO编程模型，升级改造聊天室
耶low的博客
04-14 151
第一章：手动搭建I/O网络通信框架1：Socket和ServerSocket入门实战，实现单聊 第二章：手动搭建I/O网络通信框架2：BIO编程模型实现群聊 第四章：手动搭建I/O网络通信框架4：AIO编程模型，聊天室终极改造 　　在第二章中用BIO编程模型，简单的实现了一个聊天室。但是其最大的问题在解释BIO时就已经说了：ServerSocket接收请求时（accept()方法）、...
AIO高并发服务器、客户端聊天室源码
04-15
I/O 与 NIO 一个比较重要的区别是我们使用 I/O 的时候往往会引入多线程，每个连接使用一个单独的线程，而 NIO 则是使用单线程或者只使用少量的多线程，每个连接共用一个线程。而由于 NIO 的非阻塞需要一直轮询，比较消耗系统资源，所以异步非阻塞模式 AIO 就诞生了。 AIO高并发服务器、客户端聊天室源码奉献。
java BIO/NIO/AIO 学习
weixin_34088598的博客
05-08 408
一、了解Unix网络编程5种I/O模型 1.1、阻塞式I/O模型 阻塞I/O(blocking I/O）模型，进程调用recvfrom，其系统调用直到数据报到达且被拷贝到应用进程的缓冲区中或者发生错误才返回。进程从调用recvfrom开始到它返回的整段时间内是被阻塞的。 1.2、非阻塞式I/O模型 当一个应用进程像这样对一个非阻塞描述字循环调用recvfrom时，我们称之为轮询（polling...
基于AIO的聊天室
ja_ge_va的博客
01-05 379
/** * 简介： * 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 396
所谓AIO，即是异步IO，它的IO操作交由操作系统完成。设置监听器（类似于一个信号处理函数），当系统IO操作完成时，会被监听器监听到，并执行相应的后续操作，然后返回。 监听器一般使用CompletionHandler。 服务器端代码：  package com.nanhao.AIOTest; import java.io.IOException; import java.net.Inet...
Java AIO实现多人聊天室
RivenDong
12-11 1559
文章目录1. 服务端代码2. 客户端代码3. 执行效果截图 1. 服务端代码 ChatServer类： package aio.server; import java.io.Closeable; import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import jav...
java网络编程源码-java-IO:java网络编程BIO，NIO,AIO源码示例
05-20
在Java中，有三种主要的I/O模型：BIO（Blocking I/O），NIO（Non-blocking I/O）和AIO（Asynchronous I/O）。这些模型各有特点，适用于不同的场景。 1. **BIO（阻塞I/O）** - BIO是最基础的I/O模型，它在Java早期...
Java NIO2详解：异步文件和网络编程
最新发布
哎 你看的博客
06-30 974
一、NIO2 简介 从NIO到NIO2： 发展历程及优势 异步IO模型： 原理和优势 核心组件： AsynchronousChannel, CompletionHandler, AsynchronousFileChannel, AsynchronousSocketChannel/AsynchronousServerSocketChannel 二、异步文件编程 AsynchronousFileChannel： 打开、读取、写入文件 CompletionHandler： 处理异步操作结果
Java网络编程-IO模型篇之从BIO、NIO、AIO到内核select、epoll剖析！
m0_73257876的博客
08-18 626
在前面咱们详细叙述了Linux五种IO模型以及Java所提供的三种IO模型支持，对于Java-IO这块内容，阻塞、非阻塞、同步、异步等这些区别就不再聊了，认真看下来本文后自然会有答案，最后是需要重点表明一点： NIO、AIO都是单线程处理多个连接，但并不代表着说永远只有一条线程对网络连接进行处理，这里所谓的单线程处理多个连接，其实本质上是指单条线程接收客户端连接。从上述这段话中应该可以得知：本质上对于客户端的网络连接照样会启动多条线程处理，只不过与BIOJava-BIO。...
一站式学习Java网络编程 全面理解BIO/NIO/AIO——学习笔记（1）
imahui的博客
04-17 256
目录前言模型发展1. URL解析与构造2. 域名DNS的解析过程3. 域名DNS查询的两种方式4. 网络分层及其协议 前言 模型发展 BIO Java 1.4以前 NIO Java 1.4 AIO Java 1.7 1. URL解析与构造 2. 域名DNS的解析过程 3. 域名DNS查询的两种方式 4. 网络分层及其协议 ...
一站式学习Java网络编程 全面理解BIO_NIO_AIO，学习手记（七）
方圆 Blog
07-23 960
AIO通信模型及实战
一站式学习Java网络编程 全面理解BIO_NIO_AIO，学习手记（八）
方圆 Blog
07-24 1144
AIO聊天室
一站式学习Java网络编程 全面理解BIO_NIO_AIO，学习手记（九）
方圆 Blog
07-25 739
完结总结
一站式学习Java网络编程 全面理解BIO_NIO_AIO，学习手记（四）
方圆 Blog
07-21 842
BIO聊天室实战
一站式学习Java网络编程 全面理解BIO_NIO_AIO，学习手记（一）
方圆 Blog
07-19 1193
网络相关的基础知识
一站式学习Java网络编程 全面理解BIO_NIO_AIO，学习手记（三）
方圆 Blog
07-20 513
BIO阻塞模型
Java NIO Selector深度解析与多人聊天室应用
"Java NIO Selector 是Java...通过学习和实践使用Java NIO Selector，开发者可以创建高性能、低延迟的网络应用程序，如服务器、并发客户端连接处理等。理解Selector的工作原理和用法，对于构建高效的并发系统至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值