NIO & Reactor

最新推荐文章于 2024-09-05 23:36:15 发布
最新推荐文章于 2024-09-05 23:36:15 发布
阅读量122 收藏
点赞数
分类专栏： reactor 文章标签： nio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37377082/article/details/116700894
版权

NIO 编程案例

服务端


import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.UUID;

public class NioServer {
	private static Map<String,SocketChannel>  clientMap =new HashMap<>();

	public static void main(String[] args) throws IOException {

		ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
		serverSocketChannel.configureBlocking(false);
		serverSocketChannel.bind(new InetSocketAddress(8899));
		Selector selector = Selector.open();
		serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

		while(selector.select()>0) {
			Set<SelectionKey> selectionKeys =selector.selectedKeys();
			for (SelectionKey selectionKey: selectionKeys) {
				if(selectionKey.isValid()&&selectionKey.isAcceptable()) {
					System.out.println("---- NioServer  Acceptable -----");
					ServerSocketChannel ssc =(ServerSocketChannel)selectionKey.channel();
					SocketChannel sc = ssc.accept();
					sc.configureBlocking(false);
					//注册事件
					sc.register(selector, SelectionKey.OP_READ);
					// 存储客户端
					String key ="【"+UUID.randomUUID()+"】";
					clientMap.put(key, sc);
				}else if(selectionKey.isValid()&&selectionKey.isReadable()) {
					ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
					System.out.println("---- NioServer  Readable -----");
					SocketChannel sc =(SocketChannel)selectionKey.channel();
					try{
						 int count = sc.read(byteBuffer);
						 byteBuffer.flip();
						 if(count>0) {
							 Charset charset =Charset.forName("UTF-8");
							 String msg = String.valueOf(charset.decode(byteBuffer).array());
							 System.out.println(sc.getLocalAddress() + " 客户端发送的信息 ： " + msg);
							 // 消息分发
							 for (Entry<String, SocketChannel>  entry: clientMap.entrySet()) {
								byteBuffer.clear();
								if(entry.getValue().equals(sc)) {
									byteBuffer.put(("自己发送的消息  :  "+ msg).getBytes());
								}else {
									byteBuffer.put( (entry.getKey() +"客户端发送的消息  :  "+ msg).getBytes() );
								}
								byteBuffer.flip();
								entry.getValue().write(byteBuffer);
							 }
						 }
					}catch (Exception e){
						selectionKey.cancel();
					}
				}
//				else if(selectionKey.isValid()&&selectionKey.isWritable()){
//					ByteBuffer bb = ByteBuffer.allocate(1024);
//					System.out.println("---- NioServer  Writable -----");
//				}
				selectionKeys.remove(selectionKey);
			}
		}


	}
}

客户端

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.charset.StandardCharsets;
import java.util.*;

public class NioClient {
	public static void client() throws IOException {
		Scanner input = new Scanner(System.in);

		SocketChannel socketChannel = SocketChannel.open();
		socketChannel.configureBlocking(false);
		socketChannel.connect(new InetSocketAddress("127.0.0.1",8899));
		Selector selector = Selector.open();
		socketChannel.register(selector, SelectionKey.OP_CONNECT);
		while(selector.select()>0) {
			Set<SelectionKey> selectionKeys =selector.selectedKeys();
			for (SelectionKey selectionKey: selectionKeys) {
				SocketChannel sc =(SocketChannel)selectionKey.channel();
				if(selectionKey.isValid()&&selectionKey.isConnectable()) {
					ByteBuffer byteBuffer= ByteBuffer.allocate(1024);
					System.out.println("---- NioClient  Connectable -----");
					sc.finishConnect();// 完成连接

					sc.register(selector,SelectionKey.OP_READ);

					byteBuffer.put( (" 服务器已接受客户端的连接 ！！！").getBytes() );
					byteBuffer.flip();
					sc.write(byteBuffer);

					// 启动新线程，监听 cmd 输入
					new Thread(()->{
						while(input.hasNext()){
							byteBuffer.clear();
							String msg = input.nextLine();
							byteBuffer.put(msg.getBytes(StandardCharsets.UTF_8));
							byteBuffer.flip();
							try {
								sc.write(byteBuffer);
							} catch (IOException e) {
								e.printStackTrace();
							}

						}
					}).start();
				}else if(selectionKey.isValid()&&selectionKey.isReadable()) {
					ByteBuffer byteBuffer= ByteBuffer.allocate(1024);
					System.out.println("---- NioClient  Readable -----");
					int count = sc.read(byteBuffer);
					byteBuffer.flip();
					if(count>0) {
						String msg= new String(byteBuffer.array(),0,count);
						System.out.println(msg);
					}
				}
//				else if(selectionKey.isValid()&&selectionKey.isWritable()){
//					ByteBuffer bb= ByteBuffer.allocate(1024);
//					System.out.println("---- NioClient  Writable -----");
//				}
//				sc.register(selector, SelectionKey.OP_READ);
				selectionKeys.remove(selectionKey);

			}
		}
	}
	public static void main(String[] args) throws IOException {
//		for (int i = 0; i < 10; i++) {
//			new Thread(()->{
//				try { client(); } catch (IOException e) { e.printStackTrace(); }
//			}) .start();
//
//		}
		try { client(); } catch (IOException e) { e.printStackTrace(); }

	}
}

Reactor

单reactor 单线程

/**
 * 处理事件的接口（接受事件，读写事件等）
 */
public interface Handler {
	// 处理事件的方法
    public void handle(Selector selector , SelectableChannel channel, SelectionKey selectionKey) ;
}
/**
 * 只是在接口的基础上做了扩展
 */
public abstract class AbstractHandler implements  Handler{
    private final List<ClientMsg> clients = new CopyOnWriteArrayList<>();

    public List<ClientMsg> getClients() {
        return clients;
    }
}
/**
 * 处理Acceptable 事件
 */
public class AcceptHandler extends AbstractHandler{
    
    public AcceptHandler()  {  }
    
    public AcceptHandler(Selector selector, ServerSocketChannel socketChannel) throws IOException {
        socketChannel.configureBlocking(false);
        SelectionKey selectionKey = socketChannel.register(selector, 0);//注册一个不存在的事件
        selectionKey.attach(this);
        selectionKey.interestOps(SelectionKey.OP_ACCEPT);//将此键的 interest 集合设置为给定值 ： 注册读事件
        selector.wakeup();//唤醒前一个阻塞的socket
    }
    
    @Override
    public void handle(Selector selector , SelectableChannel channel, SelectionKey selectionKey) {
        try{
            if(selectionKey.isAcceptable()){
                SocketChannel socketChannel = ((ServerSocketChannel)channel).accept();
                if(socketChannel!=null) { 
                    new ReaderHandler(selector,socketChannel);
                }
            }
        }catch (Exception e){
            selectionKey.cancel();
        }
    }
}

/**
 * 处理Reader事件
 */
public class ReaderHandler extends AbstractHandler{

    static final int MAX_IN = 1024;
    static ByteBuffer input = ByteBuffer.allocate(MAX_IN);
    public ReaderHandler()  {
    }
    public ReaderHandler(Selector selector, SocketChannel socketChannel) throws IOException {
        socketChannel.configureBlocking(false);
        // 也可以注解注册SelectionKey.OP_READ; 这里先不关心任何事件， 后面注册读事件
        SelectionKey selectionKey = socketChannel.register(selector, 0);//注册一个不存在的事件
        selectionKey.attach(this);
        selectionKey.interestOps(SelectionKey.OP_READ);//将此键的 interest 集合设置为给定值 ： 注册读事件
        selector.wakeup();//唤醒前一个阻塞的socket
    }

    public ReaderHandler(Selector selector, SocketChannel socketChannel,SelectionKey selectionKey) throws IOException {
        socketChannel.configureBlocking(false);
        // 也可以注解注册SelectionKey.OP_READ; 这里先不关心任何事件， 后面注册读事件
        selectionKey = socketChannel.register(selector, 0);//注册一个不存在的事件
        selectionKey.attach(this);
        selectionKey.interestOps(SelectionKey.OP_READ);//将此键的 interest 集合设置为给定值 ： 注册读事件
        selector.wakeup();//唤醒前一个阻塞的socket
    }

    @Override
    public void handle(Selector selector, SelectableChannel channel, SelectionKey selectionKey)  {
        try{
            SocketChannel socketChannel = (SocketChannel) channel;
            input.clear();
            //读入
            socketChannel.read(input);
            input.flip();
            // 写出到String
            String msg = String.valueOf( Charset.forName("UTF-8").decode(input).array() );
            System.out.println("---ReaderHandler.handle() msg : " + msg);
            // 处理数据
            process();
            // 读取完毕后 注入Writer 事件
            if(socketChannel!=null) new WriterHandler(selector,socketChannel);
        }catch (Exception e){
            selectionKey.cancel();
        }
    }
    boolean inputIsComplete() {
        // 加入实现
        return true;
    }

    void process() {
        // 加入实现
    }
}

/**
 *  处理 Writer 事件
 */
public class WriterHandler extends AbstractHandler{
    static final int MAX_OUT = 1024;
    static ByteBuffer output = ByteBuffer.allocate(MAX_OUT);
    public WriterHandler()  {
    }
    public WriterHandler(Selector selector, SocketChannel socketChannel) throws IOException {
        socketChannel.configureBlocking(false);
        SelectionKey selectionKey = socketChannel.register(selector, 0);//注册一个不存在的事件
        selectionKey.attach(this);
        selectionKey.interestOps(SelectionKey.OP_WRITE);//注册写事件
        selector.wakeup();//唤醒前一个阻塞的socket
    }

    @Override
    public void handle(Selector selector, SelectableChannel channel, SelectionKey selectionKey)  {
        try{
            SocketChannel socketChannel = (SocketChannel) channel;
            output.clear();
            String msg = "默认消息\n";
            process();
            output.put(msg.getBytes());
            output.flip();
            socketChannel.write(output);
            System.out.println("---WriterHandler.handle() msg : " + msg);
//        if (outputIsComplete()) {
//            selectionKey.cancel();
//        }
			// 读取完毕后 注入Reader事件
            if(socketChannel!=null) new ReaderHandler(selector,(SocketChannel)selectionKey.channel());
        }catch (Exception e){
            selectionKey.cancel();
        }

    }

    boolean outputIsComplete() {
        // 加入实现
        return true;
    }

    void process() {
        // 加入实现
    }
}
/**
 *  核心类Reactor 
 */
public class Reactor implements Runnable{
    final Selector selector;
    final ServerSocketChannel serverSocketChannel;

    /**
     * reactor 1: 初始设置
     */
    Reactor(int port) throws IOException {
        System.out.println("----Reactor 构造函数" );
        selector = Selector.open();
        serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.socket().bind(new InetSocketAddress(port));
        AcceptHandler acceptor= new AcceptHandler(selector,serverSocketChannel);
    }
    /**
     * reactor 2: 分发循环
     */
    @Override
    public void run() {
        try {
            System.out.println("----Reactor.run() 的线程名 : "+Thread.currentThread().getName()+"\n");
            while (!Thread.interrupted() ) {//获取注册事件
                selector.select(); //这个方法是阻塞方法 ，而selector.wakeup()会唤醒阻塞中的selector
                Set<SelectionKey> sks = selector.selectedKeys();
                Iterator<SelectionKey> it = sks.iterator();
                while (it.hasNext()) {
                    SelectionKey selectionKey = it.next();
                    dispatcher(selectionKey);//分发每一个请求
                }
                // 也可以在while循环中使用iterator的remove方法
                sks.clear();

            }
        } catch (IOException ignored) {
            // ignored
        }
    }

    private void dispatcher(SelectionKey selectionKey) throws IOException {
        Selector selector = selectionKey.selector();
        SelectableChannel channel  = selectionKey.channel();
        Handler handler = (Handler) selectionKey.attachment();//获取之前绑定的对象
        if (null != handler) {
            handler.handle(selector,channel,selectionKey);
        }
    }

    public static void main(String[] args) throws Exception {
        Reactor reactor= new Reactor(8899);
        new Thread(reactor).start();//这就是 reactor 线程 服务端线程
    }
}

单reactor 多线程

主从reactor 多线程
合肥东仔
关注
专栏目录
【NIO系列】——之Reactor模型（三）
Java圈全能架构师的博客
06-05 727
在开篇之前，我们对JavaNIO 的使用方式不做过多介绍，这种API的介绍方式网上太多了，没必要详细介绍，我们假设NIO的使用方式，你能够熟练运用。这是NIO系列第三篇: 【NIO系列】——之TCP探秘 【NIO系列】——之IO模型 通过之前的Unix的IO模型介绍，想必也了解到了5种IO模型。java的NIO是属于同步非阻塞IO，关于IO多路复用，java没有相应的IO模型，但有相应的编程模式，Reactor 就是基于NIO中实现多路复用的一种模式。本文将从以下几点阐述Reactor模式： .
Java NIO、Reactor、Netty
ZXW601498616的博客
03-27 953
文章目录1.NIO概述2.Channel3.Buffer4.Selector5.内存映射文件 1.NIO概述   NIO包括：Channel、Buffer、Selector   NIO是面向缓冲区的，传统IO是面向流的；传统IO基于字节流、字符流进行操作。NIO基于Channel和Buffer进行操作，数据总是从Channel读到Buffer，从Buffer写到Channel。传统IO是阻塞的，N...
NIO-Reactor
少年不识愁滋味
12-12 282
NIO和BIO 多路IO复用 Reactor模式 高性能IO的发展历程:单线程阻塞->多线程并发->事件驱动NIO 单线程阻塞：最大问题是无法并发，效率太低，当前请求没有处理完，后面的请求一直排队等待，通常是一个while循环，accept，有数据后执行，执行完成后执行while下一次循环 多线程并发：一个连接一个线程，缺点是：资源要求太高，系统中创建线程是需要比较高的系统资源的，如果连接数太高，系统无法承受，而且，线程的反复创建-销毁也需要代价。 事件驱动NIO：reactor模型，当有事件触
NIO、Reactor模式与直接内存
最新发布
m0_45164511的博客
09-05 996
本文主要讲解网络通信的NIO模型、Reactor模式以及直接内存。它们在开发中都是很常见的底层知识，了解他们的原理，可以帮助我们更好的使用高级开发的工具。
【NIO系列】——之Reactor模型
weixin_34133829的博客
07-11 1371
在开篇之前，我们对JavaNIO 的使用方式不做过多介绍，这种API的介绍方式网上太多了，没必要详细介绍，我们假设NIO的使用方式，你能够熟练运用。这是NIO系列第三篇:【NIO系列】——之TCP探秘【NIO系列】——之IO模型通过之前的Unix的IO模型介绍，想必也了解到了5种IO模型。java的NIO是属于同步非阻塞IO，关于IO多路复用，java没有相应的IO模型，但有相应的编程模式，Rea...
循序渐进教你实现一个完整的node的EventEmitter模块
liwusen的博客
07-25 4344
node的事件模块只包含了一个类：EventEmitter。这个类在node的内置模块和第三方模块中大量使用。EventEmitter本质上是一个观察者模式的实现，这种模式可以扩展node在多个进程或网络中运行。本文从node的EventEmitter的使用出发，循序渐进的实现一个完整的EventEmitter模块。 EventEmitter模块的基本用法和简单实现 node...
认识node核心模块--深入EventEmitter
weixin_34233618的博客
11-03 144
原文地址在我的博客，转载请注明出处，谢谢！ node 采用了事件驱动机制，而EventEmitter 就是node实现事件驱动的基础。在EventEmitter的基础上，node 几乎所有的模块都继承了这个类，以实现异步事件驱动架构。继承了EventEmitter的模块，拥有了自己的事件，可以绑定／触发监听器，实现了异步操作。EventE...
java基于NIO实现Reactor模型源码.zip
06-01
java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现...
java nio and reactor
07-10
java nio 作者的ppt。 How to Build a Scalable Multiplexed Server With NIO 文中讲述如何使用java nio来实现高性能的服务器。...2、java nio 和 reactor 的映射关系 3、如果使用java nio 来实现高性能服务器
「NIO系列」——之Reactor模型
lt_xiaodou的博客
07-31 680
通过之前的Unix的IO模型介绍，想必也了解到了5种IO模型。java的NIO是属于同步非阻塞IO，关于IO多路复用，java没有相应的IO模型，但有相应的编程模式，Reactor就是基于NIO中实现多路复用的一种模式。本文将从以下几点阐述Reactor模式reactor是什么为何要用，能解决什么问题如何用，更好的方式其他事件处理模式。...
java nio&netty系列之三netty网络模型代码以及简化版代码示例
04-19
首先，Netty的核心是它的事件驱动模型，也称为Reactor模式。在Netty中，BossGroup负责接收新的连接请求，WorkerGroup则处理已连接的SocketChannel上的读写事件。BossGroup通常只有一个线程，而WorkerGroup可以有多个...
reactor:NIO 编程模型 - Reactor，各版本实现
05-29
Reactor 依据 Doug Lea 的 基于 NIO 实现的 Reacotr 模式的回显服务器 BasicHandler: 单线程处理器 MultiReactor: 主从 Reactor MultithreadHandler: 线程池处理器 Reactor: 接收连接，I/O 读写 Reactor 模型的说明： Getting started 编译 javac -encoding utf-8 *.java 运行 java Reactor java MultiReactor 测试 使用 telnet 命令进行测试，在 windows 下记得打开回显（ctrl+] -> set localecho -> Enter） D:\>telnet 127.0.0.1 10393 Implementation of Reactor Design Partten by tonwu.net react
java nio 多路复用_【NIO系列】——之Reactor模型
weixin_39611546的博客
11-26 190
在开篇之前，我们对JavaNIO 的使用方式不做过多介绍，这种API的介绍方式网上太多了，没必要详细介绍，我们假设NIO的使用方式，你能够熟练运用。这是NIO系列第三篇:【NIO系列】——之TCP探秘【NIO系列】——之IO模型通过之前的Unix的IO模型介绍，想必也了解到了5种IO模型。java的NIO是属于同步非阻塞IO，关于IO多路复用，java没有相应的IO模型，但有相应的编程模式，Rea...
一文聊聊Node.js中的EventEmitter模块
qq_43067585的博客
07-28 873
EventEmitter是 Node.js 的内置模块，为我们提供了事件订阅机制。下面本篇文章就来带大家了解一下Node.js中的EventEmitter模块，介绍一下它的用法，希望对大家有所帮助！
Node.js的EventEmitter
赵佳敏的博客
05-13 247
Node.js的EventEmitter一、Node.js EventEmitter简单介绍二、EventEmitter类 一、Node.js EventEmitter简单介绍 Node.js 所有的异步 I/O 操作在完成时都会发送一个事件到事件队列。 Node.js 里面的许多对象都会分发事件：一个 net.Server 对象会在每次有新连接时触发一个事件， 一个 fs.readStream 对象会在文件被打开的时候触发一个事件。 所有这些产生事件的对象都是 events.EventEmit.
NIO Reactor模型
weixin_40849725的博客
08-18 515
NIO Reactor模型Reactor三种模型单线程模型多线程模型主从多线程模型Netty线程模型1 线程组2 ChannelPipeline3 异步非阻塞 Reactor模式是基于事件驱动开发的，服务端程序处理传入多路请求，并将它们同步分派给请求对应的处理线程，Reactor模式也叫Dispatcher模式，即I/O多路复用统一监听事件，收到事件后分发（Dispatch给某进程），这是编写高性能网络服务器的必备技术之一。 Reactor模式以NIO为底层支持，核心组成部分包括Reactor和Ha
NIO Reactor模型 & Netty线程模型
luzhensmart的专栏
08-19 500
1、Reactor模式思想：分而治之+事件驱动 1）分而治之 一个连接里完整的网络处理过程一般分为accept、read、decode、process、encode、send这几步。 Reactor模式将每个步骤映射为一个Task，服务端线程执行的最小逻辑单元不再是一次完整的网络请求，而是Task，且采用非阻塞方式执行。 2）事件驱动 每个Task对应特定网络事件。当Task准备就绪时，...
【Reactor】学习redis线程模型有感
weixin_30549657的博客
08-10 295
https://my.oschina.net/u/1859679/blog/1844109 该模式可以有简单实现、也可以多线程实现、要看场景，比喻redis的实现就是简单，因为都是基于内存操作。 学习下！ 基于Reactor Pattern 处理模式中，定义以下三种角色: Reactor将I/O事件分派给对应的Handler Acceptor...
java模式之Reactor
atrueman123的专栏
12-20 1085
Java　NIO非堵塞应用通常适用用在I/O读写等方面，我们知道，系统运行的性能瓶颈通常在I/O读写，包括对端口和文件的操作上，过去，在打开一个I/O通道后，read()将一直等待在端口一边读取字节内容，如果没有内容进来，read()也是傻傻的等，这会影响我们程序继续做其他事情，那么改进做法就是开设线程，让线程去等待，但是这样做也是相当耗费资源的。Java NIO非堵塞技术实际是采取Reactor模式，或者说是Observer模式为我们监察I/O端口，如果有内容进来，会自动通知我们，这样，我们就不必开启多个
Java NIO reactor模式解析与实战
反应器模式（Reactor Pattern）是Java NIO中的一种设计模式，它是一种事件驱动的设计模式，用于处理大量并发事件。在NIO中，反应器主要负责监听和分发网络连接事件，当一个连接有新的读写事件发生时，反应器会将事件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值