用nio实现Echo服务--代码

最新推荐文章于 2018-07-16 12:27:56 发布
最新推荐文章于 2018-07-16 12:27:56 发布
阅读量151 收藏
点赞数
分类专栏： 非阻塞io 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/action5362603/article/details/84603899
版权

今天突然间想用nio实现个Echo服务，程序实现起来实现不算困难，但跑起来后，在Server端的ServerSocket完成accept之后，我的CPU总是跳到100%。嗯，小郁闷，后来，才发现自己在Server端注册了多余的监听事件SelectionKey.OP_WRITE，改过来后好多了，希望记住这个教训。

 

EchoServer.java

Java代码 复制代码  收藏代码
  1. package edu.dlut.zxf.nio;  
  2.   
  3. import java.io.IOException;  
  4. import java.net.InetAddress;  
  5. import java.net.InetSocketAddress;  
  6. import java.nio.ByteBuffer;  
  7. import java.nio.channels.SelectionKey;  
  8. import java.nio.channels.Selector;  
  9. import java.nio.channels.ServerSocketChannel;  
  10. import java.nio.channels.SocketChannel;  
  11. import java.util.Set;  
  12.   
  13. /** 
  14.  * Echo服务器 
  15.  * @author finux 
  16.  */  
  17. public class EchoServer {  
  18.     public final static int BUFFER_SIZE = 1024; //默认端口  
  19.     public final static String HOST = "210.30.107.17";  
  20.     public final static int PORT = 8888;  
  21.       
  22.     public static void main(String[] args) {  
  23.         ServerSocketChannel ssc = null;  
  24.         //缓冲区  
  25.         ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);  
  26.         Selector selector = null;  
  27.         try {  
  28.             selector = Selector.open();  
  29.             ssc = ServerSocketChannel.open();  
  30.             ssc.socket().bind(new InetSocketAddress(InetAddress.getByName(HOST), PORT));  
  31.             ssc.configureBlocking(false);  
  32.             ssc.register(selector, SelectionKey.OP_ACCEPT);       
  33.             print("服务器启动，准备好连接...");  
  34.             while (selector.select() > 0) {        
  35.                 Set<SelectionKey> selectionKeys = selector.selectedKeys();  
  36.                 for (SelectionKey key: selectionKeys) {  
  37.                     if (key.isAcceptable()) {  
  38.                         SocketChannel sc = ssc.accept();  
  39.                         print("有新的连接！地址：" + sc.socket().getRemoteSocketAddress());  
  40.                         sc.configureBlocking(false);  
  41.                         sc.register(selector, SelectionKey.OP_READ);  
  42.                         // 不要写成:  
  43.                         // sc.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE);  
  44.                         // 毕竟这样多注册的无用的事件SelectionKey.OP_WRTE  
  45.                         // 如果是这样，在完成accept后，CPU也许会跑到100%  
  46.                           
  47.                     }  
  48.                     //same to if ((ops & SelectionKey.OP_READ) == SelectionKey.OP_READ) {  
  49.                     if (key.isReadable()) {   
  50.                         SocketChannel sc = (SocketChannel)key.channel();  
  51.                         print("有新的读取！地址：" + sc.socket().getRemoteSocketAddress());                        
  52.                         buffer.clear();                       
  53.                         sc.read(buffer);  
  54.                         buffer.flip();  
  55.                         byte[] b = new byte[buffer.limit()];  
  56.                         buffer.get(b);  
  57.                         String s = new String(b);  
  58.                         if (s.equals("bye")) {  
  59.                             print("断开连接：" + sc.socket().getRemoteSocketAddress());    
  60.                             //断开连接后，取消此键的通道到其选择器的注册  
  61.                             key.cancel();  
  62.                             sc.close();  
  63.                             continue;  
  64.                         }  
  65.                         print("读取的内容为：" + s);     
  66.                         buffer.clear();  
  67.                         s = "echo: " + s;  
  68.                         buffer.put(s.getBytes());  
  69.                         buffer.flip();  
  70.                         sc.write(buffer);  
  71.                     }   
  72.                 }  
  73.                 selectionKeys.clear();  
  74.             }  
  75.         } catch(IOException e) {  
  76.             e.printStackTrace();  
  77.         }   
  78.     }  
  79.       
  80.     private static void print(String s) {  
  81.         System.out.println(s);  
  82.     }  
  83. }  
package edu.dlut.zxf.nio;

import java.io.IOException;
import java.net.InetAddress;
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.util.Set;

/**
 * Echo服务器
 * @author finux
 */
public class EchoServer {
	public final static int BUFFER_SIZE = 1024; //默认端口
	public final static String HOST = "210.30.107.17";
	public final static int PORT = 8888;
	
	public static void main(String[] args) {
		ServerSocketChannel ssc = null;
		//缓冲区
		ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
		Selector selector = null;
		try {
			selector = Selector.open();
			ssc = ServerSocketChannel.open();
			ssc.socket().bind(new InetSocketAddress(InetAddress.getByName(HOST), PORT));
			ssc.configureBlocking(false);
			ssc.register(selector, SelectionKey.OP_ACCEPT);		
			print("服务器启动，准备好连接...");
			while (selector.select() > 0) {		
				Set<SelectionKey> selectionKeys = selector.selectedKeys();
				for (SelectionKey key: selectionKeys) {
					if (key.isAcceptable()) {
						SocketChannel sc = ssc.accept();
						print("有新的连接！地址：" + sc.socket().getRemoteSocketAddress());
						sc.configureBlocking(false);
						sc.register(selector, SelectionKey.OP_READ);
						// 不要写成:
						// sc.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE);
						// 毕竟这样多注册的无用的事件SelectionKey.OP_WRTE
						// 如果是这样，在完成accept后，CPU也许会跑到100%
						
					}
					//same to if ((ops & SelectionKey.OP_READ) == SelectionKey.OP_READ) {
					if (key.isReadable()) { 
						SocketChannel sc = (SocketChannel)key.channel();
						print("有新的读取！地址：" + sc.socket().getRemoteSocketAddress());						
						buffer.clear();						
						sc.read(buffer);
						buffer.flip();
						byte[] b = new byte[buffer.limit()];
						buffer.get(b);
						String s = new String(b);
						if (s.equals("bye")) {
							print("断开连接：" + sc.socket().getRemoteSocketAddress());	
							//断开连接后，取消此键的通道到其选择器的注册
							key.cancel();
							sc.close();
							continue;
						}
						print("读取的内容为：" + s);	
						buffer.clear();
						s = "echo: " + s;
						buffer.put(s.getBytes());
						buffer.flip();
						sc.write(buffer);
					} 
				}
				selectionKeys.clear();
			}
		} catch(IOException e) {
			e.printStackTrace();
		} 
	}
	
	private static void print(String s) {
		System.out.println(s);
	}
}

 

EchoClient.java

Java代码 复制代码  收藏代码
  1. package edu.dlut.zxf.nio;  
  2.   
  3. import java.util.Set;  
  4. import java.io.BufferedReader;  
  5. import java.io.IOException;  
  6. import java.io.InputStreamReader;  
  7. import java.net.InetSocketAddress;  
  8. import java.net.InetAddress;  
  9. import java.nio.ByteBuffer;  
  10. import java.nio.channels.SelectionKey;  
  11. import java.nio.channels.Selector;  
  12. import java.nio.channels.SocketChannel;  
  13.   
  14. /** 
  15.  * Echo客户端 
  16.  * @author finux 
  17.  */  
  18. public class EchoClient {  
  19.     public static void main(String[] args) {  
  20.         ByteBuffer buffer = ByteBuffer.allocate(EchoServer.BUFFER_SIZE);  
  21.         Selector selector = null;  
  22.         SocketChannel sc = null;  
  23.         try {  
  24.             selector = Selector.open();  
  25.             sc = SocketChannel.open();  
  26.             sc.configureBlocking(false);  
  27.             sc.connect(new InetSocketAddress(InetAddress.getByName(EchoServer.HOST), EchoServer.PORT));  
  28.             print("客户端启动，准备连接...");  
  29.             if (sc.isConnectionPending()) {  
  30.                 sc.finishConnect();  
  31.             }  
  32.             print("完成连接");  
  33.             sc.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE);  
  34.               
  35.             boolean writed = false;  
  36.             boolean down = false;  
  37.             while (!down && selector.select() > 0) {               
  38.                 Set<SelectionKey> selectionKeys = selector.selectedKeys();  
  39.                 for (SelectionKey key: selectionKeys) {                   
  40.                     //int ops = key.readyOps();  
  41.                     //if ((ops & SelectionKey.OP_WRITE) == SelectionKey.OP_WRITE && !writed) {  
  42.                     if (key.isWritable() && !writed) {  
  43.                         System.out.print("Input(bye to end): ");  
  44.                         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));   
  45.                         String s = br.readLine();  
  46.                         if (s != null && !s.trim().equals("")) {  
  47.                             buffer.clear();  
  48.                             buffer.put(s.getBytes());  
  49.                             buffer.flip();  
  50.                             sc.write(buffer);  
  51.                             writed = true;  
  52.                             if (s.equals("bye")) {  
  53.                                 down = true;  
  54.                                 break;  
  55.                             }  
  56.                         }  
  57.                     }  
  58.                     //if ((ops & SelectionKey.OP_READ) == SelectionKey.OP_READ && writed) {  
  59.                     if (key.isReadable() && writed) {  
  60.                         buffer.clear();  
  61.                         sc.read(buffer);  
  62.                         buffer.flip();  
  63.                         byte[] b = new byte[buffer.limit()];  
  64.                         buffer.get(b);  
  65.                         print(new String(b));  
  66.                         writed = false;  
  67.                     }  
  68.                 }  
  69.                 selectionKeys.clear();  
  70.             }  
  71.         } catch(IOException e) {  
  72.             e.printStackTrace();  
  73.         }  
  74.     }  
  75.       
  76.     private static void print(String s) {  
  77.         System.out.println(s);  
  78.     }  
  79. }  
package edu.dlut.zxf.nio;

import java.util.Set;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.InetSocketAddress;
import java.net.InetAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;

/**
 * Echo客户端
 * @author finux
 */
public class EchoClient {
	public static void main(String[] args) {
		ByteBuffer buffer = ByteBuffer.allocate(EchoServer.BUFFER_SIZE);
		Selector selector = null;
		SocketChannel sc = null;
		try {
			selector = Selector.open();
			sc = SocketChannel.open();
			sc.configureBlocking(false);
			sc.connect(new InetSocketAddress(InetAddress.getByName(EchoServer.HOST), EchoServer.PORT));
			print("客户端启动，准备连接...");
			if (sc.isConnectionPending()) {
				sc.finishConnect();
			}
			print("完成连接");
			sc.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE);
			
			boolean writed = false;
			boolean down = false;
			while (!down && selector.select() > 0) {				
				Set<SelectionKey> selectionKeys = selector.selectedKeys();
				for (SelectionKey key: selectionKeys) {					
					//int ops = key.readyOps();
					//if ((ops & SelectionKey.OP_WRITE) == SelectionKey.OP_WRITE && !writed) {
					if (key.isWritable() && !writed) {
						System.out.print("Input(bye to end): ");
						BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 
						String s = br.readLine();
						if (s != null && !s.trim().equals("")) {
							buffer.clear();
							buffer.put(s.getBytes());
							buffer.flip();
							sc.write(buffer);
							writed = true;
							if (s.equals("bye")) {
								down = true;
								break;
							}
						}
					}
					//if ((ops & SelectionKey.OP_READ) == SelectionKey.OP_READ && writed) {
					if (key.isReadable() && writed) {
						buffer.clear();
						sc.read(buffer);
						buffer.flip();
						byte[] b = new byte[buffer.limit()];
						buffer.get(b);
						print(new String(b));
						writed = false;
					}
				}
				selectionKeys.clear();
			}
		} catch(IOException e) {
			e.printStackTrace();
		}
	}
	
	private static void print(String s) {
		System.out.println(s);
	}
}

 

当然EchoClient也可以像下面这样来实现：

EchoClient2.java

Java代码 复制代码  收藏代码
  1. package edu.dlut.zxf.nio;  
  2.   
  3. import java.util.Set;  
  4. import java.io.BufferedReader;  
  5. import java.io.IOException;  
  6. import java.io.InputStreamReader;  
  7. import java.net.InetSocketAddress;  
  8. import java.net.InetAddress;  
  9. import java.nio.ByteBuffer;  
  10. import java.nio.channels.SelectionKey;  
  11. import java.nio.channels.Selector;  
  12. import java.nio.channels.SocketChannel;  
  13.   
  14. /** 
  15.  * Echo客户端2 
  16.  * @author finux 
  17.  */  
  18. public class EchoClient2 {  
  19.     public static void main(String[] args) {  
  20.         ByteBuffer buffer = ByteBuffer.allocate(EchoServer.BUFFER_SIZE);  
  21.         Selector selector = null;  
  22.         SocketChannel sc = null;  
  23.         try {  
  24.             selector = Selector.open();  
  25.             sc = SocketChannel.open();  
  26.             sc.configureBlocking(false);  
  27.             sc.register(selector, SelectionKey.OP_CONNECT);  
  28.             sc.connect(new InetSocketAddress(InetAddress.getByName(EchoServer.HOST), EchoServer.PORT));  
  29.             print("客户端启动，准备连接...");  
  30.               
  31.             boolean writed = false;  
  32.             boolean down = false;  
  33.             while (!down && selector.select() > 0) {               
  34.                 Set<SelectionKey> selectionKeys = selector.selectedKeys();  
  35.                 for (SelectionKey key: selectionKeys) {                   
  36.                     //int ops = key.readyOps();  
  37.                     //if ((ops & SelectionKey.OP_CONNECT) == SelectionKey.OP_CONNECT) {  
  38.                     if (key.isConnectable()) {  
  39.                         print("完成连接！");  
  40.                         if (sc.isConnectionPending()) {  
  41.                             sc.finishConnect();  
  42.                         }  
  43.                         sc.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE);                  
  44.                     }  
  45.                     //if ((ops & SelectionKey.OP_WRITE) == SelectionKey.OP_WRITE && !writed) {  
  46.                     if (key.isWritable() && !writed) {  
  47.                         //从准备IO中读取内容  
  48.                         System.out.print("Input(bye to end): ");  
  49.                         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));   
  50.                         String s = br.readLine();  
  51.                         if (s != null && !s.trim().equals("")) {  
  52.                             buffer.clear();  
  53.                             buffer.put(s.getBytes());  
  54.                             buffer.flip();  
  55.                             sc.write(buffer);  
  56.                             writed = true;  
  57.                             if (s.equals("bye")) {  
  58.                                 down = true;  
  59.                                 break;  
  60.                             }  
  61.                         }  
  62.                     }  
  63.                     //if ((ops & SelectionKey.OP_READ) == SelectionKey.OP_READ && writed) {  
  64.                     if (key.isReadable() && writed) {  
  65.                         buffer.clear();  
  66.                         sc.read(buffer);  
  67.                         buffer.flip();  
  68.                         byte[] b = new byte[buffer.limit()];  
  69.                         buffer.get(b);  
  70.                         print(new String(b));  
  71.                         writed = false;  
  72.                     }  
  73.                 }  
  74.                 selectionKeys.clear();  
  75.             }  
  76.         } catch(IOException e) {  
  77.             e.printStackTrace();  
  78.         }  
  79.     }  
  80.       
  81.     private static void print(String s) {  
  82.         System.out.println(s);  
  83.     }  
  84. }  
package edu.dlut.zxf.nio;

import java.util.Set;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.InetSocketAddress;
import java.net.InetAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;

/**
 * Echo客户端2
 * @author finux
 */
public class EchoClient2 {
	public static void main(String[] args) {
		ByteBuffer buffer = ByteBuffer.allocate(EchoServer.BUFFER_SIZE);
		Selector selector = null;
		SocketChannel sc = null;
		try {
			selector = Selector.open();
			sc = SocketChannel.open();
			sc.configureBlocking(false);
			sc.register(selector, SelectionKey.OP_CONNECT);
			sc.connect(new InetSocketAddress(InetAddress.getByName(EchoServer.HOST), EchoServer.PORT));
			print("客户端启动，准备连接...");
			
			boolean writed = false;
			boolean down = false;
			while (!down && selector.select() > 0) {				
				Set<SelectionKey> selectionKeys = selector.selectedKeys();
				for (SelectionKey key: selectionKeys) {					
					//int ops = key.readyOps();
					//if ((ops & SelectionKey.OP_CONNECT) == SelectionKey.OP_CONNECT) {
					if (key.isConnectable()) {
						print("完成连接！");
						if (sc.isConnectionPending()) {
							sc.finishConnect();
						}
						sc.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE);				
					}
					//if ((ops & SelectionKey.OP_WRITE) == SelectionKey.OP_WRITE && !writed) {
					if (key.isWritable() && !writed) {
						//从准备IO中读取内容
						System.out.print("Input(bye to end): ");
						BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 
						String s = br.readLine();
						if (s != null && !s.trim().equals("")) {
							buffer.clear();
							buffer.put(s.getBytes());
							buffer.flip();
							sc.write(buffer);
							writed = true;
							if (s.equals("bye")) {
								down = true;
								break;
							}
						}
					}
					//if ((ops & SelectionKey.OP_READ) == SelectionKey.OP_READ && writed) {
					if (key.isReadable() && writed) {
						buffer.clear();
						sc.read(buffer);
						buffer.flip();
						byte[] b = new byte[buffer.limit()];
						buffer.get(b);
						print(new String(b));
						writed = false;
					}
				}
				selectionKeys.clear();
			}
		} catch(IOException e) {
			e.printStackTrace();
		}
	}
	
	private static void print(String s) {
		System.out.println(s);
	}
}

但是这样的话，显然EchoClient2中的while循环中的for循环（若有n次），在每次循环中都会多出n-1次if判断，就是下面这个：

Java代码 复制代码  收藏代码
  1. if (key.isConnectable()) {  
if (key.isConnectable()) {

所以，我个人更喜欢第一个EchoClient，呵呵，不用注册SelectionKey.OP_CONNECT监听事件。呵呵...

action5362603
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《Netty实战》中的 echo 代码-netty-echo.zip
01-30
在"echo"代码示例中，Netty展示了如何实现一个简单的回显服务器，该服务器接收到客户端发送的数据后，会原封不动地将数据返回给客户端。这是一个基础但非常重要的概念，它帮助我们理解网络通信的基本原理，并为构建...
Java中的BIO,NIO,AIO详解以及Echo实现示例
scugxl的专栏
02-01 2668
Abstract 在本博客当中我们主要会分为如下几点: Java中的BIO NIO AIO是啥 BIO NIO AIO实现的简单Echo client和server NIO AIO 深入之内部实现 NIO AIO的设计模式: Reactor 以及 Proactor 本文所有的代码都可以在最后的github找到. IO 的分类 BIO BIO 是 blocking io, 在jdk1.0的时候引...
基于Nio的echo server和echo client
A_D_wocaoni的专栏
04-05 215
最近想学netty，但平常工作中NIO用的比较少，所以最近就复习了下NIO。自己写了个基于NIO的echo例子，代码挺简单的。 [size=medium][color=red]echo 服务端代码[/color][/size] [code="java"] package study.nio.echo; import java.io.IOException; import ja...
使用NIO实现一个echo服务器
yanghan1222的博客
05-26 701
    一个简单的echo服务器，客户端向服务端发送消息，服务端进行响应，当客户端发送quit字符串时，断开客户端和服务端的连接。使用NIO实现    服务端代码public class EchoServer_NIO { private Selector selector; private ByteBuffer sendBuf = ByteBuffer.allocate(1024)...
使用原生NIO实现一个echo服务器
NON blog
01-07 474
tcp的拆包处理使用的是定长解码的方式。 服务器端：public class EchoServer { public static final int port = 8888; public static void main(String[] args) throws IOException { Selector selector = Selector.open();
Java NIO 实现 EchoServer EchoClient
12-21 2819
阻塞模式EchoServer采用阻塞模式，用线程池中的工作线程处理每个客户连接。 EchoClient也采用阻塞模式，单线程。serverpackage com.test.socket.nio.echo;import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java
使用UDP实现Echo服务.rar_Echo Echo_java udp
09-23
在本教程中，我们将详细讨论如何使用Java编程语言实现一个基于UDP（User Datagram Protocol）的Echo服务。 UDP是传输层的一个无连接协议，与TCP相比，它不提供诸如确认、流量控制或重传等机制。这意味着UDP通信更轻...
采用NIO实现一个Socket服务器
08-03
本篇将基于给定的标题“采用NIO实现一个Socket服务器”来详细阐述如何使用NIO进行Socket服务端的开发。 首先，理解NIO的核心概念： 1. **通道(Channel)**：通道是连接到I/O设备的途径，可以读取或写入数据。常见的...
Java Socket学习---nio实现阻塞多线程通信
06-01
本篇文章将深入探讨如何使用Java NIO（非阻塞I/O）来实现阻塞多线程通信，这对于高性能服务器端应用尤其重要。我们将会分析`EchoServer.java`、`EchoClient.java`和`SocketUtils.java`这三个文件中的关键知识点。 ...
NIO与传统IO代码区别实例
01-24
相比之下，NIO服务器的实现方式会有所不同，它使用选择器来管理多个连接，并且只用一个线程来处理所有连接。不过，由于这个示例的压缩包中并未包含NIO服务器的代码，因此无法提供具体的NIO代码示例。但你可以查阅...
使用nio实现简单Echo服务
zhuxianfeng的专栏
07-04 140
最近温习下nio API，无聊写个Echo服务，直接上代码了，有点懒，具体细节不解释，查阅API或源码吧，没有公开的src就反编译下。   EchoServer.java   package com.iteye.finux.echo; import java.io.IOException; import java.net.InetAddress; import java.net....
（NIO-框架）--Netty（三）模拟Echo服务器案例--DelimiterBasedFrameDecoder（以分隔符做消息解码）FixedLengthFrameDecoder(定长)
liuyancainiao的博客
07-16 628
package com.taikang.echo.echoclient; import io.netty.bootstrap.Bootstrap; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelFuture; import io.netty.chann...
使用 NIO 实现 echo 服务器
jijianshuai的专栏
08-21 1842
NIO相关知识点IO、NIO、AIO 内部原理分析 NIO 之 Selector实现原理 NIO 之 Channel实现原理 NIO 之 ByteBuffer实现原理服务器使用NIO来实现一个echo协议的服务器。 echo协议简单也很有用，可以测试网络连接。消息的格式为：消息长度（int）+消息内容通过消息长度来进行socket分包，防止读取出现半包、粘包等问题。服务端import jav
[转]用nio实现Echo服务
caoruntaogmail的博客
03-10 111
[转]http://finux.iteye.com/blog/368955   今天突然间想用nio实现个Echo服务，程序实现起来实现不算困难，但跑起来后，在Server端的ServerSocket完成accept之后，我的CPU总是跳到100%。嗯，小郁闷，后来，才发现自己在Server端注册了多余的监听事件SelectionKey.OP_WRITE，改过来后好多了，希望记住这个教训。 ...
JavaNIO--3.Reactor模式实现echo服务器
CringKong的博客
05-03 547
一、什么是Reactor模式 1.1概念 1.2NIO如何实现Reactor模式 二、JavaNIO实现基于Reactor模式的ECHO服务器 2.1初始化事件处理器（service handler) 2.2多路复用+循环分发 2.3同步任务派发器（dispatch） 2.4请求处理器（Request Handler） 三、完整代码 四、测试结果 一、什么是Reactor模式...
JavaNIO--2.实现ECHO服务器
CringKong的博客
05-02 739
JavaNIO技术实现ECHO服务器 1.NIO核心组件的使用 1.1初始化NIO组件 1.2Accept组件 1.3SelectLoop（核心组件） 2.NIO通道读写（Buffer) 2.1读取通道内容 2.2Buffer处理辅助方法 3.测试结果 4.完整代码 JavaNIO技术实现ECHO服务器 所谓ECHO服务器就是客户端发送到服务器端什么内容，服务器端就返回...
Practical Netty (5) TCP反向代理服务器
行动起来
10-31 948
Practical Netty (5) TCP反向代理服务器 作者：柳大·Poechant（钟超） 邮箱：zhongchao.ustc#gmail.com（# -&gt; @） 博客：Blog.CSDN.net/Poechant 微博：weibo.com/lauginhom 日期：June 11th, 2012 以下针对 TCP 反向代理服务器。 1. 前端连接被创建时，...
Netty5源码分析--4.总结
行动起来
04-26 668
JAVA NIO 复习 请先参考我之前的博文JAVA学习笔记–3.Network IO的 NIO（NonBlocking IO） SOCKET 章节。这里主要讲下JAVA NIO其中几个比较被忽略的细节，不求全，欢迎补充。   API Select 当调用ServerSocketChannel.accept();时，如果该channel处于非阻塞状态而且没有等 待(pending)的...
运用spring注解实现netty服务器端udp应用程序
行动起来
11-09 636
netty是JBOSS针对网络开发的一套应用框架，它也是在NIO的基础上发展起来的。netty基于异步的事件驱动，具有高性能、高扩展性等特性，它提供了统一的底层协议接口，使得开发者从底层的网络协议（比如 TCP/IP、UDP）中解脱出来。就使用来说，开发者只要参考 Netty提供的若干例子和它的指南文档，就可以放手开发基于Netty的服务端程序了。    netty有几个比较重要的概念，在此...
[http-nio2-8088-exec-66]和[http-nio2-8088-exec-是不同线程吗]
最新发布
06-02
不是不同的线程，而是同一个线程池中的不同线程。在 Java Web 应用程序中，通常使用线程池来处理请求，以避免频繁地创建和销毁线程。线程池中的每个线程都有一个唯一的编号，但是线程的名称通常包含一些有用的信息，如协议、端口、请求编号等，以方便定位和追踪线程。在这里，“http-nio2-8088-exec-”表示使用 NIO2 协议、8088 端口，而“66”则是线程池中的第 66 个线程。因此，[http-nio2-8088-exec-66] 和 [http-nio2-8088-exec-] 是同一个线程池中的不同线程。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值