基于事件的NIO多线程服务器

最新推荐文章于 2024-08-02 15:51:11 发布
最新推荐文章于 2024-08-02 15:51:11 发布
阅读量586 收藏
点赞数
分类专栏： Java 文章标签： 多线程 exception 服务器 server string class

JDK1.4的NIO有效解决了原有流式IO存在的线程开销的问题，在NIO中使用多线程，主要目的已不是为了应对每个客户端请求而分配独立的服务线程，而是通过多线程充分使用用多个CPU的处理能力和处理中的等待时间，达到提高服务能力的目的。

多线程的引入，容易为本来就略显复杂的NIO代码进一步降低可读性和可维护性。引入良好的设计模型，将不仅带来高性能、高可靠的代码，也将带来一个惬意的开发过程。

线程模型

NIO的选择器采用了多路复用（Multiplexing）技术，可在一个选择器上处理多个套接字， 通过获取读写通道来进行IO操作。由于网络带宽等原因，在通道的读、写操作中是容易出现等待的， 所以在读、写操作中引入多线程，对性能提高明显，而且可以提高客户端的感知服务质量。所以本文的模型将主要通过使用读、写线程池 来提高与客户端的数据交换能力。

如下图所示，服务端接受客户端请求后，控制线程将该请求的读通道交给读线程池，由读线程池分配线程完成对客户端数据的读取操作；当读线程完成读操作后，将数据返回控制线程，进行服务端的业务处理；完成 业务处理后，将需回应给客户端的数据和写通道提交给写线程池，由写线程完成向客户端发送回应数据的操作。


（NIO 多线程服务器模型）

同时整个服务端的流程处理，建立于事件机制上。在 [ 接受连接－＞读－＞业务处理－＞写 － ＞关闭连接 ] 这个 过程中，触发器将触发相应事件，由事件处理器对相应事件分别响应，完成服务器端的业务处理。
下面我们就来详细看一下这个模型的各个组成部分。

 




回页首


相关事件定义 在这个模型中，我们定义了一些基本的事件：

（1）onAccept：当服务端收到客户端连接请求时，触发该事件。通过该事件我们可以知道有新的客户端呼入。该事件可用来控制服务端的负载。例如，服务器可设定同时只为一定数量客户端提供服务，当同时请求数超出数量时，可在响应该事件时直接抛出异常，以拒绝新的连接。

（2）onAccepted：当客户端请求被服务器接受后触发该事件。该事件表明一个新的客户端与服务器正式建立连接。

（3）onRead：当客户端发来数据，并已被服务器控制线程正确读取时，触发该事件 。该事件通知各事件处理器可以对客户端发来的数据进行实际处理了。需要注意的是，在本模型中，客户端的数据读取是由控制线程交由读线程完成的，事件处理器不需要在该事件中进行专门的读操作，而只需将控制线程传来的数据进行直接处理即可。

（4）onWrite：当客户端可以开始接受服务端发送数据时触发该事件，通过该事件，我们可以向客户端发送回应数据。 在本模型中，事件处理器只需要在该事件中设置

（5）onClosed：当客户端与服务器断开连接时触发该事件。

（6）onError：当客户端与服务器从连接开始到最后断开连接期间发生错误时触发该事件。通过该事件我们可以知道有什么错误发生。

 




回页首


事件回调机制的实现

在这个模型中，事件采用广播方式，也就是所有在册的事件处理器都能获得事件通知。这样可以将不同性质的业务处理，分别用不同的处理器实现，使每个处理器的业务功能尽可能单一。
如下图：整个事件模型由监听器、事件适配器、事件触发器、事件处理器组成。


（事件模型）

  1. 监听器（Serverlistener）：这是一个事件接口，定义需监听的服务器事件，如果您需要定义更多的事件，可在这里进行扩展。 
    	public interface Serverlistener {
   public void onError(String error);
   public void onAccept() throws Exception;
   public void onAccepted(Request request) throws Exception;
   public void onRead(Request request) throws Exception;
   public void onWrite(Request request, Response response) throws Exception;
   public void onClosed(Request request) throws Exception;
}
  2. 事件适配器（EventAdapter）：对Serverlistener接口实现一个适配器(EventAdapter)，这样的好处是最终的事件处理器可以只处理所关心的事件。 
    public abstract class EventAdapter implements Serverlistener {
    public EventAdapter() {
    }
    public void onError(String error) {}
    public void onAccept() throws Exception {}
    public void onAccepted(Request request)  throws Exception {}
    public void onRead(Request request)  throws Exception {}
    public void onWrite(Request request, Response response)  throws Exception {}
    public void onClosed(Request request)  throws Exception {}
}
  3. 事件触发器（Notifier）：用于在适当的时候通过触发服务器事件，通知在册的事件处理器对事件做出响应。触发器以Singleton模式实现，统一控制整个服务器端的事件，避免造成混乱。 
    public class Notifier {
    private static Arraylist listeners = null;
    private static Notifier instance = null;
    private Notifier() {
        listeners = new Arraylist();
    }
    /**
     * 获取事件触发器
     * @return 返回事件触发器
     */
    public static synchronized Notifier getNotifier() {
        if (instance == null) {
            instance = new Notifier();
            return instance;
        }
        else return instance;
    }
    /**
     * 添加事件监听器
     * @param l 监听器
     */
    public void addlistener(Serverlistener l) {
        synchronized (listeners) {
            if (!listeners.contains(l))
                listeners.add(l);
        }
    }
    public void fireOnAccept() throws Exception {
        for (int i = listeners.size() - 1; i >= 0; i--)
            ( (Serverlistener) listeners.get(i)).onAccept();
    }
    ....// other fire method
}
  4. 事件处理器（Handler）：继承事件适配器，对感兴趣的事件进行响应处理，实现业务处理。以下是一个简单的事件处理器实现，它响应onRead事件，在终端打印出从客户端读取的数据。 
    public class ServerHandler extends EventAdapter {
    public ServerHandler() {
    }
    public void onRead(Request request) throws Exception {
        System.out.println("Received: " + new String(data));
    }
}
  5. 事件处理器的注册。为了能让事件处理器获得服务线程的事件通知，事件处理器需在触发器中注册。 
    ServerHandler handler = new ServerHandler();
Notifier.addlistener(handler);

 




回页首


实现NIO多线程服务器

NIO多线程服务器主要由主控服务线程、读线程和写线程组成。


（线程模型）

  1. 主控服务线程（Server）：主控线程将创建读、写线程池，实现监听、接受客户端请求，同时将读、写通道提交由相应的读线程（Reader）和写服务线程(Writer） ，由读写线程分别完成对客户端数据的读取和对客户端的回应操作。 
    public class Server implements Runnable {
    ....
    private static int MAX_THREADS = 4;
    public Server(int port) throws Exception {
        ....
        // 创建无阻塞网络套接
        selector = Selector.open();
        sschannel = ServerSocketChannel.open();
        sschannel.configureBlocking(false);
        address = new InetSocketAddress(port);
        ServerSocket ss = sschannel.socket();
        ss.bind(address);
        sschannel.register(selector, SelectionKey.OP_ACCEPT);
    }
    public void run() {
        System.out.println("Server started ...");
        System.out.println("Server listening on port: " + port);
        // 监听
        while (true) {
            try {
                int num = 0;
                num = selector.select();
                if (num > 0) {
                    Set selectedKeys = selector.selectedKeys();
                    Iterator it = selectedKeys.iterator();
                    while (it.hasNext()) {
                        SelectionKey key = (SelectionKey) it.next();
                        it.remove();
                        // 处理IO事件
                        if ( (key.readyOps() & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT) {
                           // Accept the new connection
                           ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
                           notifier.fireOnAccept();
                           SocketChannel sc = ssc.accept();
                           sc.configureBlocking(false);
                           // 触发接受连接事件
                           Request request = new Request(sc);
                           notifier.fireOnAccepted(request);
                           
                           // 注册读操作,以进行下一步的读操作
                           sc.register(selector,  SelectionKey.OP_READ, request);
                       }
                       else if ( (key.readyOps() & SelectionKey.OP_READ) == SelectionKey.OP_READ ) {
                           Reader.processRequest(key);  // 提交读服务线程读取客户端数据
                           key.cancel();
                       }
                       else if ( (key.readyOps() & SelectionKey.OP_WRITE) == SelectionKey.OP_WRITE ) {
                           Writer.processRequest(key);  // 提交写服务线程向客户端发送回应数据
                           key.cancel();
                       }
                    }
                }
                else {
                    addRegister();  // 在Selector中注册新的写通道
                }
            }
            catch (Exception e) {
                notifier.fireOnError("Error occured in Server: " + e.getMessage());
                continue;
            }
        }
    }
    ....
}
  2. 读线程（Reader）：使用线程池技术，通过多个线程读取客户端数据，以充分利用网络数据传输的时间，提高读取效率。 
    public class Reader extends Thread {
    public void run() {
        while (true) {
            try {
                SelectionKey key;
                synchronized (pool) {
                    while (pool.isEmpty()) {
                        pool.wait();
                    }
                    key = (SelectionKey) pool.remove(0);
                }
                // 读取客户端数据，并触发onRead事件
                read(key);  
            }
            catch (Exception e) {
                continue;
            }
        }
    }
    ....
}
  3. 写线程（Writer）：和读操作一样，使用线程池，负责将服务器端的数据发送回客户端。 
    public final class Writer extends Thread {
    public void run() {
        while (true) {
            try {
                SelectionKey key;
                synchronized (pool) {
                    while (pool.isEmpty()) {
                        pool.wait();
                    }
                    key = (SelectionKey) pool.remove(0);
                }
                // 向客户端发送数据，然后关闭连接，并分别触发onWrite，onClosed事件
                write(key); 
            }
            catch (Exception e) {
                continue;
            }
        }
    }
    ....
}

 




回页首


具体应用

NIO多线程模型的实现告一段落，现在我们可以暂且将NIO的各个API和烦琐的调用方法抛于脑后，专心于我们的实际应用中。
我们用一个简单的TimeServer（时间查询服务器）来看看该模型能带来多么简洁的开发方式。
在这个TimeServer中，将提供两种语言（中文、英文）的时间查询服务。我们将读取客户端的查询命令（GB/EN），并回 应相应语言格式的当前时间。在应答客户的请求的同时，服务器将进行日志记录。做为示例，对日志记录，我们只是简单地将客户端的访问时间和IP地址输出到服 务器的终端上。

  1. 实现时间查询服务的事件处理器（TimeHandler）： 
    public class TimeHandler extends EventAdapter {
    public TimeHandler() {
    }
    public void onWrite(Request request, Response response) throws Exception {
        String command = new String(request.getDataInput());
        String time = null;
        Date date = new Date();
        // 判断查询命令
        if (command.equals("GB")) {
            // 中文格式
            DateFormat cnDate = DateFormat.getDateTimeInstance(DateFormat.FulL,
                DateFormat.FulL, Locale.CHINA);
            time = cnDate.format(date);
        }
        else {
            // 英文格式
            DateFormat enDate = DateFormat.getDateTimeInstance(DateFormat.FulL,
                DateFormat.FulL, Locale.US);
            time = enDate.format(date);
        }
        response.send(time.getBytes());
    }
}

  2. 实现日志记录服务的事件处理器（LogHandler）： 
    public class LogHandler extends EventAdapter {
    public LogHandler() {
    }
    public void onClosed(Request request) throws Exception {
        String log = new Date().toString() + " from " + request.getAddress().toString();
        System.out.println(log);
    }
    public void onError(String error) {
        System.out.println("Error: " + error);
    }
}
  3. 启动程序： 
    public class Start {
    public static void main(String[] args) {
        try {
            LogHandler loger = new LogHandler();
            TimeHandler timer = new TimeHandler();
            Notifier notifier = Notifier.getNotifier();
            notifier.addlistener(loger);
            notifier.addlistener(timer);
            System.out.println("Server starting ...");
            Server server = new Server(5100);
            Thread tServer = new Thread(server);
            tServer.start();
        }
        catch (Exception e) {
            System.out.println("Server error: " + e.getMessage());
            System.exit(-1);
        }
    }
}

 




回页首


小结

通过例子我们可以看到，基于事件回调的NIO多线程服务器模型，提供了清晰直观的实现方式，可让开发者从NIO及多线程的技术细节中摆脱出来，集中精力关注具体的业务实现。

 




回页首


附录

演示程序（ nioserver.zip ）。

freeglad
关注
专栏目录
NIO-实践-多线程实例
09-28
NIO用于高性能Socket编程由来已久，网络也有较为丰富的原理和源代码。我这里主要介绍几点经验总结： 1.Selector.select()在筛选就绪的SelectionKey的时候，采用的是阻塞模式。同时只要在就绪的SelectionKey列表中有至少一个SelectionKey存在，前述方法均将返回。 SocketChannel被Selector检查，检查其声称可以接受的状态是否已经产生，如当SocketChannel在向Selector注册是设置了可接受状态为Read，此时当SocketChannel接收到数据后将进入可读状态。 如果需要实现一个线程或有效个线程负责对SocketChannel数据的读操作，为了保证线程安全，同一时间需要保证只有一个线程在负责读操作。即需要采用SelectionKey.cancel()从注册的Selector中取消对该Selection的监视，防止同时多个线程获取到SelectionKey的事件 2.注册在向Selector注册通道的时候，如果register方法抛出KeyCancelledException表明，当前正在注册的SocketChannel在前一阶段已经注册过，但对应的SelectionKey已处于Cancel状态，此时，应该将通道的注册至于Selector.select()之后注册，这样可以在注册通道时保证SelectionKey的状态不为cancel 本文粘贴多线程在NIO环境下的基本运用示例代码，同时演示了一个线程如何对多个连接进行读写的操作。
Java 多线程NIO
Java之上
07-04 8030
  IO模型 1. 阻塞IO如果数据没有准备就绪，就一直等待，直到数据准备就绪；整个进程会被阻塞。2. 非阻塞IO需不断询问内核是否已经准备好数据，非阻塞虽然不用等待但是一直占用CPU。3. 多路复用IO NIO多路复用IO，会有一个线程不断地去轮询多个socket的状态，当socket有读写事件的时候才会调用IO读写操作。用一个线程管理多个socket，是通过selector.select(...
Java的NIO以及线程并发
weixin_30745553的博客
02-11 163
一、NIO的出现NIO是JDK1.4里面才出现的东东，他给大家带来的最大好处是异步socket。其它file,pipe暂时就不多谈了。 在JDK1.4出现之前，如果你需要编写一个Java服务器，为了实现异步操作，你必须为每个连接请求生成一个Java线程，当连接请求很多时，线程的调度，上下文切换，所付出的代价是非常昂贵，而且由于Java是跨平台的，各个平台对线程的支持并...
基于事件的_NIO_多线程服务器
05-06
### 基于事件的NIO多线程服务器解析 #### 概述 在Java的网络编程中，NIO（Non-blocking I/O）作为一种高效的数据处理模式，自JDK 1.4版本引入以来，逐渐成为了开发高性能网络应用的重要工具之一。与传统的阻塞I/O...
基于事件的 NIO 多线程服务器
04-07
总结起来，基于事件的NIO多线程服务器是一种强大的设计模式，它利用Java NIO库实现了高效的并发连接管理。通过分析和研究给定的"nioserver"和"timeserver"代码，我们可以深入掌握NIO的核心概念和实际应用，这对于...
Java实现基于NIO的多线程Web服务器实例
08-19
Java实现基于NIO的多线程Web服务器实例 Java实现基于NIO的多线程Web服务器实例是使用Java语言基于NIO（New I/O）技术实现的多线程Web服务器。NIO技术可以提供高性能、低延迟的I/O操作，非常适合高并发的Web服务器。...
NIO的多线程形式
weixin_43885566的博客
06-16 569
https://blog.csdn.net/MOTUI/article/details/52792146
java多线程的nio_Java多线程NIO学习
weixin_35034536的博客
03-08 332
阻塞IO 如果数据没有准备就绪，就一直等待，直到数据准备就绪；整个进程会被阻塞。非阻塞IO 需不断询问内核是否已经准备好数据，非阻塞虽然不用等待但是一直占用CPU。多路复用IO NIO 多路复用IO，会有一个线程不断地去轮询多个socket的状态，当socket有读写事件的时候才会调用IO读写操作。 用一个线程管理多个socket，是通过selector.select()查询每个通道是否有事件到达...
多线程（11） — NIO
diandao9404的博客
08-12 297
　　Java NIO是new IO的简称，是一种可以替代Java IO的一套新的IO机制。它提供了一套不同于Java标准IO的操作机制，严格来说，NIO与并发并无直接关系，但是使用NIO技术可以大大提高线程的使用效率。Java NIO设计的基础内容有通道（Channel）、缓冲区（Buffer）、Selector（选择器）。下面说说这几个内容 1）通道（Channel） 　　Chan...
java nio 线程_JAVA NIO 结合多线程
weixin_31143391的博客
02-12 784
NIO 的选择器采用了多路复用(Multiplexing)技术，可在一个选择器上处理多个套接字， 通过获取读写通道来进行 IO 操作。由于网络带宽等原因，在通道的读、写操作中是容易出现等待的， 所以在读、写操作中引入多线程，对性能提高明显，而且可以提高客户端的感知服务质量。所以本文的模型将主要通过使用读、写线程池 来提高与客户端的数据交换能力。如下图所示，服务端接受客户端请求后，控制线程将该请求的...
NIO和Netty编程（一）之多线程编程
zengdongwen的博客
07-19 1383
1、基本知识回顾 线程是比进程更小的能独立运行的基本单位，它是进程的一部分，一个进程可以拥有多个线程，但至少要有一个线程，即主执行线程(Java 的main 方法)。我们既可以编写单线程应用，也可以编写多线程应用。一个进程中的多个线程可以并发(同时)执行，在一些执行时间长、需要等待的任务上（例如：文件读写和网络传输等），多线程就比较有用了。 怎么理解多线程呢？来两个例子： 1....
NIO-TCP通信实例（单线程，多线程Server）
Donald_Draper的专栏
04-14 185
ww.iteye.com/magazines/132-Java-NIO[/url] NIO-TCP简单实例：[url]http://donald-draper.iteye.com/admin/blogs/2369044[/url] 在这篇文章之前用BIO实现过TCP的通信，即Java Socket通信实例这篇文章，那边文章 主要利用BIO的ServerSocket和Socket实现加法和乘法的实现，今天我们来用NIO的 ServerSocketChannel和SocketChannel来实现加法和乘
JavaNIO--4.多线程Reactor模式
CringKong的博客
05-08 1489
单线程VS多线程 1.模型代码 1.1Reactor模型 1.Handler模型 2.自己实现的多线程echo服务器（基于Reactor模式） 2.1 Reactor 2.2 Handler 单线程VS多线程 写在前面： 也就是说多线程实现echo服务器实际上是不太科学的选择，但是本文依旧是实现了一个echo服务器。为了不误人子弟，所以请谨慎观看第二部分——自...
【Netty】从0到1（五）：NIO-多线程优化
z1ztai的博客
05-20 200
这前几篇文章中，都是采用单线程进行设计，虽然可以运行，但是没有充分利用 CPU 的性能，并且如果有一个事件的处理时间较长，则会影响其他事件的处理。例如，开发一个项目，如果团队只有一个全栈工程师，那么他需要先完成前端，再完成后端，只能按部就班的完成任务，如果前端开发遭遇困难，花费了很多时间，则会大大拉长项目开发周期，而如果一个团队里有前端工程师和后端工程师，则前后端的开发能同步进行，这样会大大提高开发效率。
NIO如何多线程操作
weixin_34163741的博客
05-18 564
2019独角兽企业重金招聘Python工程师标准>>> ...
Java NIO服务端多线程化问题
最新发布
qq_20157013的博客
08-02 1513
工作中有这么一个项目，电动车充电桩使用socket与服务器通信，项目于今年一月份上线，一直平稳运行，近期由于充电桩数量激增，socket服务端压力倍增，导致服务端开放的端口连接不上。分析代码，发现服务端使用的单线程模式。
NIO多线程服务器设计：事件驱动与线程池优化
"本文介绍了如何构建一个基于事件的NIO多线程服务器，利用Java NIO的非阻塞特性以及多线程技术提高服务端的并发处理能力和效率。NIO的核心在于选择器，它允许单个线程管理多个通道，从而减少线程创建和上下文切换的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值