yypiao
yypiao

Netty学习之旅------线程模型前置篇Reactor反应堆设计模式实现（基于java.nio）

阅读更多

<转自http://blog.csdn.net/prestigeding/article/details/55100075?locationNum=11&fps=1>

版权声明：本文为博主原创文章，未经博主允许不得转载。

1、Reactor反应堆设计模式

1.1、单线程模型

Netty学习之旅------线程模型前置篇Reactor反应堆设计模式实现（基于java.nio）_第1张图片

                          单线程模型Reactor(此图来源与网络)

下面以Java nio为基础，实现Reactor模型。

Nio服务端代码：

 

[java] view plain copy
 
print ?
  1. package threadmode.r1;  
  2.   
  3. import java.io.IOException;  
  4. import java.net.InetSocketAddress;  
  5. import java.nio.ByteBuffer;  
  6. import java.nio.channels.SelectionKey;  
  7. import java.nio.channels.Selector;  
  8. import java.nio.channels.ServerSocketChannel;  
  9. import java.nio.channels.SocketChannel;  
  10. import java.util.Iterator;  
  11. import java.util.Set;  
  12.   
  13. /** 
  14.  * Nio服务器， 
  15.  * 本例主要用来增加对 Ractor 线程模型的理解，不会考虑半包等网络问题 
  16.  *  
  17.  * 例子程序的功能：服务器接受客户端的请求数据，然后在后面再追加 (hello,服务器收到了你的信息。) 
  18.  * @author dingwei2 
  19.  *  
  20.  *  
  21.  *  
  22.  *  
  23.  * 
  24.  */  
  25. public class NioServer {  
  26.   
  27.     public static void main(String[] args) {  
  28.         // TODO Auto-generated method stub  
  29.           
  30.         //   
  31.         (new Thread(new Reactor())).start();  
  32.   
  33.     }  
  34.       
  35.     /** 
  36.      * Reactor模型，反应堆 
  37.      * @author dingwei2 
  38.      * 
  39.      */  
  40.     private static final class Reactor implements Runnable {  
  41.           
  42. //      private static final ConcurrentHashMap waitSendData   
  43. //                                          = new ConcurrentHashMap();  
  44.           
  45.         private static final byte[] b = "hello,服务器收到了你的信息。".getBytes();  
  46.   
  47.         public void run() {  
  48.             // TODO Auto-generated method stub  
  49.             System.out.println("服务端启动成功，等待客户端接入");  
  50.             ServerSocketChannel ssc = null;  
  51.             Selector selector = null;  
  52.             try {  
  53.                 ssc = ServerSocketChannel.open();  
  54.                 ssc.configureBlocking(false);  
  55.                 ssc.bind(new InetSocketAddress("127.0.0.1", 9080));  
  56.                   
  57.                 selector = Selector.open();  
  58.                 ssc.register(selector, SelectionKey.OP_ACCEPT);  
  59.                   
  60.                 Set ops = null;  
  61.                 while(true) {  
  62.                     try {  
  63.                         selector.select(); //如果没有感兴趣的事件到达，阻塞等待  
  64.                         ops = selector.selectedKeys();  
  65.                     } catch(Throwable e) {  
  66.                         e.printStackTrace();  
  67.                         break;  
  68.                     }  
  69.                       
  70.                     //处理相关事件  
  71.                     for (Iterator it = ops.iterator(); it.hasNext();) {  
  72.                         SelectionKey key =  it.next();  
  73.                         it.remove();  
  74.                           
  75.                         try {  
  76.                             if(key.isAcceptable()) { //客户端建立连接  
  77.                                 ServerSocketChannel serverSc = (ServerSocketChannel) key.channel();//这里其实，可以直接使用ssl这个变量  
  78.                                 SocketChannel clientChannel = serverSc.accept();  
  79.                                 clientChannel.configureBlocking(false);  
  80.                                   
  81.                                 //向选择器注册读事件，客户端向服务端发送数据准备好后，再处理  
  82.                                 clientChannel.register(selector, SelectionKey.OP_READ);  
  83.                                   
  84.                                 System.out.println("收到客户端的连接请求。。。");  
  85.                             } else if (key.isWritable()) { //向客户端发送请求  
  86.                                 SocketChannel clientChannel = (SocketChannel)key.channel();  
  87.                                 ByteBuffer buf = (ByteBuffer)key.attachment();  
  88.                                 buf.flip();  
  89.                                 clientChannel.write(buf);  
  90.                                 System.out.println("服务端向客户端发送数据。。。");  
  91.                                 //重新注册读事件  
  92.                                 clientChannel.register(selector, SelectionKey.OP_READ);  
  93.                             } else if(key.isReadable()) {  //处理客户端发送的数据  
  94.                                 System.out.println("服务端接收客户端连接请求。。。");  
  95. //                              System.out.println(key);  
  96.                                 SocketChannel clientChannel = (SocketChannel)key.channel();  
  97. //                              System.out.println("clientChannel.isConnected():" + clientChannel.isConnected());  
  98. //                              System.out.println("clientChannel.isConnectionPending():" +clientChannel.isConnectionPending());  
  99. //                              System.out.println("clientChannel.isOpen():" + clientChannel.isOpen());  
  100. //                              System.out.println("clientChannel.finishConnect():" + clientChannel.finishConnect());  
  101.                                 ByteBuffer buf = ByteBuffer.allocate(1024);  
  102.                                 System.out.println(buf.capacity());  
  103.                                 clientChannel.read(buf);//  
  104.                                 buf.put(b);  
  105.                                 clientChannel.register(selector, SelectionKey.OP_WRITE, buf);//注册写事件  
  106.                             }  
  107.                         } catch(Throwable e) {  
  108.                             e.printStackTrace();  
  109.                             System.out.println("客户端主动断开连接。。。。。。。");  
  110.                             ssc.register(selector, SelectionKey.OP_ACCEPT);  
  111.                         }  
  112.                           
  113.                     }  
  114.                 }  
  115.                   
  116.             } catch (IOException e) {  
  117.                 // TODO Auto-generated catch block  
  118.                 e.printStackTrace();  
  119.             }  
  120.               
  121.         }  
  122.           
  123.     }  
  124.   
  125. }  
package threadmode.r1;

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.util.Iterator;
import java.util.Set;

/**
 * Nio服务器，
 * 本例主要用来增加对 Ractor 线程模型的理解，不会考虑半包等网络问题
 * 
 * 例子程序的功能：服务器接受客户端的请求数据，然后在后面再追加 (hello,服务器收到了你的信息。)
 * @author dingwei2
 * 
 * 
 * 
 * 
 *
 */
public class NioServer {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		// 
		(new Thread(new Reactor())).start();

	}
	
	/**
	 * Reactor模型，反应堆
	 * @author dingwei2
	 *
	 */
	private static final class Reactor implements Runnable {
		
//		private static final ConcurrentHashMap waitSendData 
//											= new ConcurrentHashMap();
		
		private static final byte[] b = "hello,服务器收到了你的信息。".getBytes();

		public void run() {
			// TODO Auto-generated method stub
			System.out.println("服务端启动成功，等待客户端接入");
			ServerSocketChannel ssc = null;
			Selector selector = null;
			try {
				ssc = ServerSocketChannel.open();
				ssc.configureBlocking(false);
				ssc.bind(new InetSocketAddress("127.0.0.1", 9080));
				
				selector = Selector.open();
				ssc.register(selector, SelectionKey.OP_ACCEPT);
				
				Set ops = null;
				while(true) {
					try {
						selector.select(); //如果没有感兴趣的事件到达，阻塞等待
						ops = selector.selectedKeys();
					} catch(Throwable e) {
						e.printStackTrace();
						break;
					}
					
					//处理相关事件
					for (Iterator it = ops.iterator(); it.hasNext();) {
						SelectionKey key =  it.next();
						it.remove();
						
						try {
							if(key.isAcceptable()) { //客户端建立连接
								ServerSocketChannel serverSc = (ServerSocketChannel) key.channel();//这里其实，可以直接使用ssl这个变量
								SocketChannel clientChannel = serverSc.accept();
								clientChannel.configureBlocking(false);
								
								//向选择器注册读事件，客户端向服务端发送数据准备好后，再处理
								clientChannel.register(selector, SelectionKey.OP_READ);
								
								System.out.println("收到客户端的连接请求。。。");
							} else if (key.isWritable()) { //向客户端发送请求
								SocketChannel clientChannel = (SocketChannel)key.channel();
								ByteBuffer buf = (ByteBuffer)key.attachment();
								buf.flip();
								clientChannel.write(buf);
								System.out.println("服务端向客户端发送数据。。。");
								//重新注册读事件
								clientChannel.register(selector, SelectionKey.OP_READ);
							} else if(key.isReadable()) {  //处理客户端发送的数据
								System.out.println("服务端接收客户端连接请求。。。");
//								System.out.println(key);
								SocketChannel clientChannel = (SocketChannel)key.channel();
//								System.out.println("clientChannel.isConnected():" + clientChannel.isConnected());
//								System.out.println("clientChannel.isConnectionPending():" +clientChannel.isConnectionPending());
//								System.out.println("clientChannel.isOpen():" + clientChannel.isOpen());
//								System.out.println("clientChannel.finishConnect():" + clientChannel.finishConnect());
								ByteBuffer buf = ByteBuffer.allocate(1024);
								System.out.println(buf.capacity());
								clientChannel.read(buf);//
								buf.put(b);
								clientChannel.register(selector, SelectionKey.OP_WRITE, buf);//注册写事件
							}
						} catch(Throwable e) {
							e.printStackTrace();
							System.out.println("客户端主动断开连接。。。。。。。");
							ssc.register(selector, SelectionKey.OP_ACCEPT);
						}
						
					}
				}
				
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		}
		
	}

}

Nio客户端代码

 

 

[java] view plain copy
 
print ?
  1. package threadmode.r1;  
  2.   
  3. import java.io.IOException;  
  4. import java.net.InetSocketAddress;  
  5. import java.nio.ByteBuffer;  
  6. import java.nio.channels.SelectionKey;  
  7. import java.nio.channels.Selector;  
  8. import java.nio.channels.SocketChannel;  
  9. import java.util.Iterator;  
  10. import java.util.Set;  
  11. /** 
  12.  * @author dingwei2 
  13.  * 
  14.  */  
  15. public class NioClient {  
  16.   
  17.     public static void main(String[] args) {  
  18.         // TODO Auto-generated method stub  
  19.           
  20.         SocketChannel clientClient;  
  21.         Selector selector = null;  
  22.         try {  
  23.             clientClient = SocketChannel.open();  
  24.             clientClient.configureBlocking(false);  
  25.               
  26.             selector = Selector.open();  
  27.               
  28.             clientClient.register(selector, SelectionKey.OP_CONNECT);  
  29.               
  30.             clientClient.connect(new InetSocketAddress("127.0.0.1",9080));  
  31.               
  32.             Set ops = null;  
  33.               
  34.             while(true) {  
  35.                 try {  
  36.                     selector.select();  
  37.                     ops = selector.selectedKeys();  
  38.                     for (Iterator it = ops.iterator(); it.hasNext();) {  
  39.                         SelectionKey key = it.next();  
  40.                         it.remove();  
  41.                         if(key.isConnectable()) {  
  42.                             System.out.println("client connect");  
  43.                             SocketChannel sc =  (SocketChannel) key.channel();  
  44.                             // 判断此通道上是否正在进行连接操作。  
  45.                             // 完成套接字通道的连接过程。  
  46.                             if (sc.isConnectionPending()) {  
  47.                                 sc.finishConnect();  
  48.                                 System.out.println("完成连接!");  
  49.                                 ByteBuffer buffer = ByteBuffer.allocate(1024);  
  50.                                 buffer.put("Hello,Server".getBytes());  
  51.                                 buffer.flip();  
  52.                                 sc.write(buffer);  
  53.                             }  
  54.                             sc.register(selector, SelectionKey.OP_READ);   
  55.                         } else if(key.isWritable()) {  
  56.                             System.out.println("客户端写");  
  57.                             SocketChannel sc = (SocketChannel)key.channel();  
  58.                             ByteBuffer buffer = ByteBuffer.allocate(1024);  
  59.                             buffer.put("hello server.".getBytes());  
  60.                             buffer.flip();  
  61.                             sc.write(buffer);  
  62.                         } else if(key.isReadable()) {  
  63.                             System.out.println("客户端收到服务器的响应....");  
  64.                             SocketChannel sc = (SocketChannel)key.channel();  
  65.                             ByteBuffer buffer = ByteBuffer.allocate(1024);  
  66.                             int count = sc.read(buffer);  
  67.                             if(count > 0 ) {  
  68.                                 buffer.flip();  
  69.                                 byte[] response = new byte[buffer.remaining()];  
  70.                                 buffer.get(response);  
  71.                                 System.out.println(new String(response));  
  72.                             }  
  73.                               
  74.                         }  
  75.                           
  76.                     }  
  77.                       
  78.                 } catch(Throwable e) {  
  79.                     e.printStackTrace();  
  80.                 }  
  81.                   
  82.             }  
  83.               
  84.               
  85.               
  86.               
  87.               
  88.               
  89.         } catch (IOException e) {  
  90.             // TODO Auto-generated catch block  
  91.             e.printStackTrace();  
  92.         }  
  93.           
  94.   
  95.     }  
  96.   
  97. }  
package threadmode.r1;

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.util.Iterator;
import java.util.Set;
/**
 * @author dingwei2
 *
 */
public class NioClient {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		SocketChannel clientClient;
		Selector selector = null;
		try {
			clientClient = SocketChannel.open();
			clientClient.configureBlocking(false);
			
			selector = Selector.open();
			
			clientClient.register(selector, SelectionKey.OP_CONNECT);
			
			clientClient.connect(new InetSocketAddress("127.0.0.1",9080));
			
			Set ops = null;
			
			while(true) {
				try {
					selector.select();
					ops = selector.selectedKeys();
					for (Iterator it = ops.iterator(); it.hasNext();) {
						SelectionKey key = it.next();
						it.remove();
						if(key.isConnectable()) {
							System.out.println("client connect");
							SocketChannel sc =  (SocketChannel) key.channel();
							// 判断此通道上是否正在进行连接操作。
							// 完成套接字通道的连接过程。
							if (sc.isConnectionPending()) {
								sc.finishConnect();
								System.out.println("完成连接!");
								ByteBuffer buffer = ByteBuffer.allocate(1024);
								buffer.put("Hello,Server".getBytes());
								buffer.flip();
								sc.write(buffer);
							}
							sc.register(selector, SelectionKey.OP_READ); 
						} else if(key.isWritable()) {
							System.out.println("客户端写");
							SocketChannel sc = (SocketChannel)key.channel();
							ByteBuffer buffer = ByteBuffer.allocate(1024);
							buffer.put("hello server.".getBytes());
							buffer.flip();
							sc.write(buffer);
						} else if(key.isReadable()) {
							System.out.println("客户端收到服务器的响应....");
							SocketChannel sc = (SocketChannel)key.channel();
							ByteBuffer buffer = ByteBuffer.allocate(1024);
							int count = sc.read(buffer);
							if(count > 0 ) {
								buffer.flip();
								byte[] response = new byte[buffer.remaining()];
								buffer.get(response);
								System.out.println(new String(response));
							}
							
						}
						
					}
					
				} catch(Throwable e) {
					e.printStackTrace();
				}
				
			}
			
			
			
			
			
			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		

	}

}

 

 

1.2 多线程模型

Netty学习之旅------线程模型前置篇Reactor反应堆设计模式实现（基于java.nio）_第2张图片

Reactor多线程模型（多个Nio线程处理网络读写）(此图来源与网络)

1.2多线程模型，就是1个线程Acceptor接受客户端的连接，然后由一组IO线程（Reactor）来执行网络的读写。

下面贴出其实现

其中NioServer中的Acceptor为接受客户端连接线程。

其中NioReactorThreadGroup为一组IO线程，NioReactorThread为具体IO线程的实现。

 

[java] view plain copy
 
print ?
  1. package threadmode.r2;  
  2.   
  3. import java.io.IOException;  
  4. import java.net.InetSocketAddress;  
  5. import java.nio.channels.SelectionKey;  
  6. import java.nio.channels.Selector;  
  7. import java.nio.channels.ServerSocketChannel;  
  8. import java.nio.channels.SocketChannel;  
  9. import java.util.Iterator;  
  10. import java.util.Set;  
  11.   
  12. public class NioServer {  
  13.   
  14.     public static void main(String[] args) {  
  15.         // TODO Auto-generated method stub  
  16.           
  17.         new Thread(new Acceptor()).start();  
  18.   
  19.     }  
  20.   
  21.     /** 
  22.      * 连接线程模型，反应堆，转发器 Acceptor 
  23.      *  
  24.      * @author dingwei2 
  25.      * 
  26.      */  
  27.     private static final class Acceptor implements Runnable {  
  28.   
  29.         private NioReactorThreadGroup nioReactorThreadGroup;  
  30.           
  31.         public Acceptor() {  
  32.             nioReactorThreadGroup = new NioReactorThreadGroup();  
  33.         }  
  34.   
  35.         public void run() {  
  36.             // TODO Auto-generated method stub  
  37.             System.out.println("服务端启动成功，等待客户端接入");  
  38.             ServerSocketChannel ssc = null;  
  39.             Selector selector = null;  
  40.             try {  
  41.                 ssc = ServerSocketChannel.open();  
  42.                 ssc.configureBlocking(false);  
  43.                 ssc.bind(new InetSocketAddress("127.0.0.1", 9080));  
  44.   
  45.                 selector = Selector.open();  
  46.                 ssc.register(selector, SelectionKey.OP_ACCEPT);  
  47.   
  48.                 Set ops = null;  
  49.                 while (true) {  
  50.                     try {  
  51.                         selector.select(); // 如果没有感兴趣的事件到达，阻塞等待  
  52.                         ops = selector.selectedKeys();  
  53.                     } catch (Throwable e) {  
  54.                         e.printStackTrace();  
  55.                         break;  
  56.                     }  
  57.   
  58.                     // 处理相关事件  
  59.                     for (Iterator it = ops.iterator(); it.hasNext();) {  
  60.                         SelectionKey key = it.next();  
  61.                         it.remove();  
  62.   
  63.                         try {  
  64.                             if (key.isAcceptable()) { // 客户端建立连接  
  65.                                 System.out.println("收到客户端的连接请求。。。");  
  66.                                 ServerSocketChannel serverSc = (ServerSocketChannel) key.channel();// 这里其实，可以直接使用ssl这个变量  
  67.                                 SocketChannel clientChannel = serverSc.accept();  
  68.                                 clientChannel.configureBlocking(false);  
  69.                                 nioReactorThreadGroup.dispatch(clientChannel); // 转发该请求  
  70.                             }  
  71.                         } catch (Throwable e) {  
  72.                             e.printStackTrace();  
  73.                             System.out.println("客户端主动断开连接。。。。。。。");  
  74.                         }  
  75.   
  76.                     }  
  77.                 }  
  78.   
  79.             } catch (IOException e) {  
  80.                 // TODO Auto-generated catch block  
  81.                 e.printStackTrace();  
  82.             }  
  83.   
  84.         }  
  85.   
  86.     }  
  87.   
  88. }  
package threadmode.r2;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

public class NioServer {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		new Thread(new Acceptor()).start();

	}

	/**
	 * 连接线程模型，反应堆，转发器 Acceptor
	 * 
	 * @author dingwei2
	 *
	 */
	private static final class Acceptor implements Runnable {

		private NioReactorThreadGroup nioReactorThreadGroup;
		
		public Acceptor() {
			nioReactorThreadGroup = new NioReactorThreadGroup();
		}

		public void run() {
			// TODO Auto-generated method stub
			System.out.println("服务端启动成功，等待客户端接入");
			ServerSocketChannel ssc = null;
			Selector selector = null;
			try {
				ssc = ServerSocketChannel.open();
				ssc.configureBlocking(false);
				ssc.bind(new InetSocketAddress("127.0.0.1", 9080));

				selector = Selector.open();
				ssc.register(selector, SelectionKey.OP_ACCEPT);

				Set ops = null;
				while (true) {
					try {
						selector.select(); // 如果没有感兴趣的事件到达，阻塞等待
						ops = selector.selectedKeys();
					} catch (Throwable e) {
						e.printStackTrace();
						break;
					}

					// 处理相关事件
					for (Iterator it = ops.iterator(); it.hasNext();) {
						SelectionKey key = it.next();
						it.remove();

						try {
							if (key.isAcceptable()) { // 客户端建立连接
								System.out.println("收到客户端的连接请求。。。");
								ServerSocketChannel serverSc = (ServerSocketChannel) key.channel();// 这里其实，可以直接使用ssl这个变量
								SocketChannel clientChannel = serverSc.accept();
								clientChannel.configureBlocking(false);
								nioReactorThreadGroup.dispatch(clientChannel); // 转发该请求
							}
						} catch (Throwable e) {
							e.printStackTrace();
							System.out.println("客户端主动断开连接。。。。。。。");
						}

					}
				}

			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		}

	}

}
[java] view plain copy
 
print ?
  1. package threadmode.r2;  
  2.   
  3. import java.nio.channels.SocketChannel;  
  4. import java.util.concurrent.atomic.AtomicInteger;  
  5.   
  6. /** 
  7.  * nio 线程组;简易的NIO线程组 
  8.  * @author dingwei2 
  9.  * 
  10.  */  
  11. public class NioReactorThreadGroup {  
  12.       
  13.     private static final AtomicInteger requestCounter = new AtomicInteger();  //请求计数器  
  14.       
  15.     private final int nioThreadCount;  // 线程池IO线程的数量  
  16.     private static final int DEFAULT_NIO_THREAD_COUNT;   
  17.     private NioReactorThread[] nioThreads;  
  18.       
  19.     static {  
  20. //      DEFAULT_NIO_THREAD_COUNT = Runtime.getRuntime().availableProcessors() > 1  
  21. //              ? 2 * (Runtime.getRuntime().availableProcessors() - 1 ) : 2;  
  22.           
  23.         DEFAULT_NIO_THREAD_COUNT = 4;  
  24.     }  
  25.       
  26.     public NioReactorThreadGroup() {  
  27.         this(DEFAULT_NIO_THREAD_COUNT);  
  28.     }  
  29.       
  30.     public NioReactorThreadGroup(int threadCount) {  
  31.         if(threadCount < 1) {  
  32.             threadCount = DEFAULT_NIO_THREAD_COUNT;  
  33.         }  
  34.         this.nioThreadCount = threadCount;  
  35.         this.nioThreads = new NioReactorThread[threadCount];  
  36.         for(int i = 0; i < threadCount; i ++ ) {  
  37.             this.nioThreads[i] = new NioReactorThread();  
  38.             this.nioThreads[i].start(); //构造方法中启动线程，由于nioThreads不会对外暴露，故不会引起线程逃逸  
  39.         }  
  40.           
  41.         System.out.println("Nio 线程数量：" + threadCount);  
  42.     }  
  43.       
  44.     public void dispatch(SocketChannel socketChannel) {  
  45.         if(socketChannel != null ) {  
  46.             next().register(socketChannel);  
  47.         }  
  48.     }  
  49.       
  50.     protected NioReactorThread next() {  
  51.         return this.nioThreads[ requestCounter.getAndIncrement() %  nioThreadCount ];  
  52.     }  
  53.       
  54.       
  55.   
  56.     public static void main(String[] args) {  
  57.         // TODO Auto-generated method stub  
  58.   
  59.     }  
  60.   
  61. }  
package threadmode.r2;

import java.nio.channels.SocketChannel;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * nio 线程组;简易的NIO线程组
 * @author dingwei2
 *
 */
public class NioReactorThreadGroup {
	
	private static final AtomicInteger requestCounter = new AtomicInteger();  //请求计数器
	
	private final int nioThreadCount;  // 线程池IO线程的数量
	private static final int DEFAULT_NIO_THREAD_COUNT; 
	private NioReactorThread[] nioThreads;
	
	static {
//		DEFAULT_NIO_THREAD_COUNT = Runtime.getRuntime().availableProcessors() > 1
//				? 2 * (Runtime.getRuntime().availableProcessors() - 1 ) : 2;
		
		DEFAULT_NIO_THREAD_COUNT = 4;
	}
	
	public NioReactorThreadGroup() {
		this(DEFAULT_NIO_THREAD_COUNT);
	}
	
	public NioReactorThreadGroup(int threadCount) {
		if(threadCount < 1) {
			threadCount = DEFAULT_NIO_THREAD_COUNT;
		}
		this.nioThreadCount = threadCount;
		this.nioThreads = new NioReactorThread[threadCount];
		for(int i = 0; i < threadCount; i ++ ) {
			this.nioThreads[i] = new NioReactorThread();
			this.nioThreads[i].start(); //构造方法中启动线程，由于nioThreads不会对外暴露，故不会引起线程逃逸
		}
		
		System.out.println("Nio 线程数量：" + threadCount);
	}
	
	public void dispatch(SocketChannel socketChannel) {
		if(socketChannel != null ) {
			next().register(socketChannel);
		}
	}
	
	protected NioReactorThread next() {
		return this.nioThreads[ requestCounter.getAndIncrement() %  nioThreadCount ];
	}
	
	

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}
[java] view plain copy
 
print ?
  1. package threadmode.r2;  
  2.   
  3. import java.io.IOException;  
  4. import java.nio.ByteBuffer;  
  5. import java.nio.channels.SelectionKey;  
  6. import java.nio.channels.Selector;  
  7. import java.nio.channels.SocketChannel;  
  8. import java.util.ArrayList;  
  9. import java.util.Iterator;  
  10. import java.util.List;  
  11. import java.util.Set;  
  12. import java.util.concurrent.locks.ReentrantLock;  
  13.   
  14. /** 
  15.  * Nio 线程，专门负责nio read,write 
  16.  * 本类是实例行代码，不会对nio,断线重连，写半包等场景进行处理,旨在理解 Reactor模型（多线程版本） 
  17.  * @author dingwei2 
  18.  * 
  19.  */  
  20. public class NioReactorThread extends Thread {  
  21.       
  22.     private static final byte[] b = "hello,服务器收到了你的信息。".getBytes(); //服务端给客户端的响应  
  23.       
  24.     private Selector selector;  
  25.     private List waitRegisterList = new ArrayList(512);  
  26.     private ReentrantLock registerLock = new ReentrantLock();  
  27.       
  28.       
  29.     public NioReactorThread() {  
  30.         try {  
  31.             this.selector = Selector.open();  
  32.         } catch (IOException e) {  
  33.             // TODO Auto-generated catch block  
  34.             e.printStackTrace();  
  35.         }  
  36.     }  
  37.       
  38.     /** 
  39.      * socket channel 
  40.      * @param socketChannel 
  41.      */  
  42.     public void register(SocketChannel socketChannel) {  
  43.         if(socketChannel != null ) {  
  44.             try {  
  45.                 registerLock.lock();  
  46.                 waitRegisterList.add(socketChannel);  
  47.             } finally {  
  48.                 registerLock.unlock();  
  49.             }  
  50.         }  
  51.     }  
  52.       
  53.     //private   
  54.   
  55.     public void run() {  
  56.         while(true) {  
  57.             Set ops = null;  
  58.             try {  
  59.                 selector.select(1000);  
  60.                 ops = selector.selectedKeys();  
  61.             } catch (IOException e) {  
  62.                 // TODO Auto-generated catch block  
  63.                 e.printStackTrace();  
  64.                 continue;  
  65.             }  
  66.               
  67.             //处理相关事件  
  68.             for (Iterator it = ops.iterator(); it.hasNext();) {  
  69.                 SelectionKey key =  it.next();  
  70.                 it.remove();  
  71.                   
  72.                 try {  
  73.                     if (key.isWritable()) { //向客户端发送请求  
  74.                         SocketChannel clientChannel = (SocketChannel)key.channel();  
  75.                         ByteBuffer buf = (ByteBuffer)key.attachment();  
  76.                         buf.flip();  
  77.                         clientChannel.write(buf);  
  78.                         System.out.println("服务端向客户端发送数据。。。");  
  79.                         //重新注册读事件  
  80.                         clientChannel.register(selector, SelectionKey.OP_READ);  
  81.                     } else if(key.isReadable()) {  //接受客户端请求  
  82.                         System.out.println("服务端接收客户端连接请求。。。");  
  83.                         SocketChannel clientChannel = (SocketChannel)key.channel();  
  84.                         ByteBuffer buf = ByteBuffer.allocate(1024);  
  85.                         System.out.println(buf.capacity());  
  86.                         clientChannel.read(buf);//  
  87.                         buf.put(b);  
  88.                         clientChannel.register(selector, SelectionKey.OP_WRITE, buf);//注册写事件  
  89.                     }  
  90.                 } catch(Throwable e) {  
  91.                     e.printStackTrace();  
  92.                     System.out.println("客户端主动断开连接。。。。。。。");  
  93.                 }  
  94.                   
  95.             }  
  96.               
  97.             //注册事件  
  98.             if(!waitRegisterList.isEmpty()) {  
  99.                 try {  
  100.                     registerLock.lock();  
  101.                     for (Iterator it = waitRegisterList.iterator(); it.hasNext();) {  
  102.                         SocketChannel sc = it.next();  
  103.                         try {  
  104.                             sc.register(selector, SelectionKey.OP_READ);  
  105.                         } catch(Throwable e) {  
  106.                             e.printStackTrace();//ignore  
  107.                         }  
  108.                         it.remove();  
  109.                     }  
  110.                       
  111.                 } finally {  
  112.                     registerLock.unlock();  
  113.                 }  
  114.             }  
  115.               
  116.               
  117.         }  
  118.     }  
  119.   
  120. }  
package threadmode.r2;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Nio 线程，专门负责nio read,write
 * 本类是实例行代码，不会对nio,断线重连，写半包等场景进行处理,旨在理解 Reactor模型（多线程版本）
 * @author dingwei2
 *
 */
public class NioReactorThread extends Thread {
	
	private static final byte[] b = "hello,服务器收到了你的信息。".getBytes(); //服务端给客户端的响应
	
	private Selector selector;
	private List waitRegisterList = new ArrayList(512);
	private ReentrantLock registerLock = new ReentrantLock();
	
	
	public NioReactorThread() {
		try {
			this.selector = Selector.open();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * socket channel
	 * @param socketChannel
	 */
	public void register(SocketChannel socketChannel) {
		if(socketChannel != null ) {
			try {
				registerLock.lock();
				waitRegisterList.add(socketChannel);
			} finally {
				registerLock.unlock();
			}
		}
	}
	
	//private 

	public void run() {
		while(true) {
			Set ops = null;
			try {
				selector.select(1000);
				ops = selector.selectedKeys();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				continue;
			}
			
			//处理相关事件
			for (Iterator it = ops.iterator(); it.hasNext();) {
				SelectionKey key =  it.next();
				it.remove();
				
				try {
					if (key.isWritable()) { //向客户端发送请求
						SocketChannel clientChannel = (SocketChannel)key.channel();
						ByteBuffer buf = (ByteBuffer)key.attachment();
						buf.flip();
						clientChannel.write(buf);
						System.out.println("服务端向客户端发送数据。。。");
						//重新注册读事件
						clientChannel.register(selector, SelectionKey.OP_READ);
					} else if(key.isReadable()) {  //接受客户端请求
						System.out.println("服务端接收客户端连接请求。。。");
						SocketChannel clientChannel = (SocketChannel)key.channel();
						ByteBuffer buf = ByteBuffer.allocate(1024);
						System.out.println(buf.capacity());
						clientChannel.read(buf);//
						buf.put(b);
						clientChannel.register(selector, SelectionKey.OP_WRITE, buf);//注册写事件
					}
				} catch(Throwable e) {
					e.printStackTrace();
					System.out.println("客户端主动断开连接。。。。。。。");
				}
				
			}
			
			//注册事件
			if(!waitRegisterList.isEmpty()) {
				try {
					registerLock.lock();
					for (Iterator it = waitRegisterList.iterator(); it.hasNext();) {
						SocketChannel sc = it.next();
						try {
							sc.register(selector, SelectionKey.OP_READ);
						} catch(Throwable e) {
							e.printStackTrace();//ignore
						}
						it.remove();
					}
					
				} finally {
					registerLock.unlock();
				}
			}
			
			
		}
	}

}
NioClient与Reactor,单线程版本一样，在这不重复给出。

 

 

上述示例代码中，其实并不是完成按照Reacor设计模式而来的，重头戏请看1.3，主从多线程模型(Reacor)实现
1.3 主从多线程模型(Reactor)

 

Netty学习之旅------线程模型前置篇Reactor反应堆设计模式实现（基于java.nio）_第3张图片

主从多线程模型（此图来源与网络）
 

重点关注点如下：

Acceeptor,职责，维护Java.nio.ServerSocketChannel类，绑定服务端监听端口，然后将该通道注册到MainRector中；

Main Reactor,监听客户端连接的反应堆，这里使用jdk并发中的Executors.newSingleThreadExecutor线程池来实现，监听客户端的连接事件(OP_ACCEPT)

Sub Reactor,目前没有使用jdk的并发池，这里用的SubReactorThreadGroup,其实现是数组，当然这里也可以使用jdk线程池，SubReactor的每一个线程都是IO线程，用来处理读，写事件。所有的IO线程公用一个业务线程池（基于juc）实现，用来处理业务逻辑，也就是运行Handel的地方。

Handel:具体业务逻辑实现，本例就是获取客户端的信息后，在请求信息后面追加一段文字，便返回给客户端。相关源码实现：

NioServer(Acceptor)的实现源码：

 

[java] view plain copy
 
print ?
  1. package persistent.prestige.demo.netty.threadmode.t3;  
  2.   
  3. import java.io.IOException;  
  4. import java.net.InetSocketAddress;  
  5. import java.nio.channels.ServerSocketChannel;  
  6. import java.util.concurrent.ExecutorService;  
  7. import java.util.concurrent.Executors;  
  8.   
  9.   
  10. /** 
  11.  * Reactor 主从Reactor模式实现 
  12.  *  
  13.  * Acceptor,其实个人认为，这里就是服务端角色 
  14.  * @author Administrator 
  15.  * 
  16.  */  
  17. public class NioServer {  
  18.       
  19.     private static final int DEFAULT_PORT = 9080;  
  20.       
  21.     public static void main(String[] args) {  
  22.           
  23.         new Thread(new Acceptor()).start();  
  24.           
  25.     }  
  26.       
  27.       
  28.     private static class Acceptor implements Runnable {  
  29.           
  30.         // main Reactor 线程池，用于处理客户端的连接请求  
  31.         private static ExecutorService mainReactor = Executors.newSingleThreadExecutor();  
  32.   
  33.         public void run() {  
  34.             // TODO Auto-generated method stub  
  35.             ServerSocketChannel ssc = null;  
  36.               
  37.             try {  
  38.                 ssc = ServerSocketChannel.open();  
  39.                 ssc.configureBlocking(false);  
  40.                 ssc.bind(new InetSocketAddress(DEFAULT_PORT));  
  41.                   
  42.                 //转发到 MainReactor反应堆  
  43.                 dispatch(ssc);  
  44.                   
  45.                 System.out.println("服务端成功启动。。。。。。");  
  46.                   
  47.             } catch (IOException e) {  
  48.                 // TODO Auto-generated catch block  
  49.                 e.printStackTrace();  
  50.             }  
  51.         }  
  52.           
  53.         private void dispatch(ServerSocketChannel ssc) {  
  54.             mainReactor.submit(new MainReactor(ssc));  
  55.         }  
  56.           
  57.     }  
  58.       
  59.   
  60. }  
package persistent.prestige.demo.netty.threadmode.t3;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.ServerSocketChannel;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


/**
 * Reactor 主从Reactor模式实现
 * 
 * Acceptor,其实个人认为，这里就是服务端角色
 * @author Administrator
 *
 */
public class NioServer {
	
	private static final int DEFAULT_PORT = 9080;
	
	public static void main(String[] args) {
		
		new Thread(new Acceptor()).start();
		
	}
	
	
	private static class Acceptor implements Runnable {
		
		// main Reactor 线程池，用于处理客户端的连接请求
		private static ExecutorService mainReactor = Executors.newSingleThreadExecutor();

		public void run() {
			// TODO Auto-generated method stub
			ServerSocketChannel ssc = null;
			
			try {
				ssc = ServerSocketChannel.open();
				ssc.configureBlocking(false);
				ssc.bind(new InetSocketAddress(DEFAULT_PORT));
				
				//转发到 MainReactor反应堆
				dispatch(ssc);
				
				System.out.println("服务端成功启动。。。。。。");
				
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		private void dispatch(ServerSocketChannel ssc) {
			mainReactor.submit(new MainReactor(ssc));
		}
		
	}
	

}
MainReactor 源码如下：

 

 

[java] view plain copy
 
print ?
  1. package persistent.prestige.demo.netty.threadmode.t3;  
  2.   
  3. import java.io.IOException;  
  4. import java.nio.channels.SelectableChannel;  
  5. import java.nio.channels.SelectionKey;  
  6. import java.nio.channels.Selector;  
  7. import java.nio.channels.ServerSocketChannel;  
  8. import java.nio.channels.SocketChannel;  
  9. import java.util.Iterator;  
  10. import java.util.Set;  
  11.   
  12.   
  13. /** 
  14.  * 主Reactor,主要用来处理连接请求的反应堆 
  15.  * @author Administrator 
  16.  * 
  17.  */  
  18. public class MainReactor implements Runnable {  
  19.       
  20.     private Selector selector;  
  21.     private SubReactorThreadGroup subReactorThreadGroup;   
  22.       
  23.     public MainReactor(SelectableChannel channel) {  
  24.         try {  
  25.             selector = Selector.open();  
  26.             channel.register(selector, SelectionKey.OP_ACCEPT);  
  27.         } catch (IOException e) {  
  28.             // TODO Auto-generated catch block  
  29.             e.printStackTrace();  
  30.         }  
  31.           
  32.         subReactorThreadGroup = new SubReactorThreadGroup(4);  
  33.     }  
  34.   
  35.     public void run() {  
  36.           
  37.         System.out.println("MainReactor is running");  
  38.         // TODO Auto-generated method stub  
  39.         while (!Thread.interrupted()) {  
  40.               
  41.             Set ops = null;  
  42.             try {  
  43.                 selector.select(1000);  
  44.                 ops = selector.selectedKeys();  
  45.             } catch (IOException e) {  
  46.                 // TODO Auto-generated catch block  
  47.                 e.printStackTrace();  
  48.             }  
  49.               
  50.             // 处理相关事件    
  51.             for (Iterator it = ops.iterator(); it.hasNext();) {    
  52.                 SelectionKey key = it.next();    
  53.                 it.remove();    
  54.                 try {    
  55.                     if (key.isAcceptable()) { // 客户端建立连接    
  56.                         System.out.println("收到客户端的连接请求。。。");    
  57.                         ServerSocketChannel serverSc = (ServerSocketChannel) key.channel();// 这里其实，可以直接使用ssl这个变量    
  58.                         SocketChannel clientChannel = serverSc.accept();    
  59.                         clientChannel.configureBlocking(false);    
  60.                         subReactorThreadGroup.dispatch(clientChannel); // 转发该请求    
  61.                     }    
  62.                 } catch (Throwable e) {    
  63.                     e.printStackTrace();    
  64.                     System.out.println("客户端主动断开连接。。。。。。。");    
  65.                 }    
  66.   
  67.             }    
  68.                 
  69.               
  70.         }  
  71.   
  72.     }  
  73.   
  74. }  
package persistent.prestige.demo.netty.threadmode.t3;

import java.io.IOException;
import java.nio.channels.SelectableChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;


/**
 * 主Reactor,主要用来处理连接请求的反应堆
 * @author Administrator
 *
 */
public class MainReactor implements Runnable {
	
	private Selector selector;
	private SubReactorThreadGroup subReactorThreadGroup; 
	
	public MainReactor(SelectableChannel channel) {
		try {
			selector = Selector.open();
			channel.register(selector, SelectionKey.OP_ACCEPT);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		subReactorThreadGroup = new SubReactorThreadGroup(4);
	}

	public void run() {
		
		System.out.println("MainReactor is running");
		// TODO Auto-generated method stub
		while (!Thread.interrupted()) {
			
			Set ops = null;
			try {
				selector.select(1000);
				ops = selector.selectedKeys();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
			// 处理相关事件  
            for (Iterator it = ops.iterator(); it.hasNext();) {  
                SelectionKey key = it.next();  
                it.remove();  
                try {  
                    if (key.isAcceptable()) { // 客户端建立连接  
                        System.out.println("收到客户端的连接请求。。。");  
                        ServerSocketChannel serverSc = (ServerSocketChannel) key.channel();// 这里其实，可以直接使用ssl这个变量  
                        SocketChannel clientChannel = serverSc.accept();  
                        clientChannel.configureBlocking(false);  
                        subReactorThreadGroup.dispatch(clientChannel); // 转发该请求  
                    }  
                } catch (Throwable e) {  
                    e.printStackTrace();  
                    System.out.println("客户端主动断开连接。。。。。。。");  
                }  

            }  
			  
            
		}

	}

}

 

 

SubReactor组，IO线程池实现：

 

[java] view plain copy
 
print ?
  1. package persistent.prestige.demo.netty.threadmode.t3;  
  2.   
  3. import java.nio.channels.SelectionKey;  
  4. import java.nio.channels.SocketChannel;    
  5. import java.util.concurrent.ExecutorService;  
  6. import java.util.concurrent.Executors;  
  7. import java.util.concurrent.atomic.AtomicInteger;    
  8.     
  9. /**  
  10.  * nio 线程组;简易的NIO线程组  
  11.  * @author dingwei2  
  12.  *  
  13.  */    
  14. public class SubReactorThreadGroup {    
  15.         
  16.     private static final AtomicInteger requestCounter = new AtomicInteger();  //请求计数器    
  17.         
  18.     private final int nioThreadCount;  // 线程池IO线程的数量    
  19.     private static final int DEFAULT_NIO_THREAD_COUNT;     
  20.     private SubReactorThread[] nioThreads;    
  21.     private ExecutorService businessExecutePool; //业务线程池  
  22.         
  23.     static {    
  24. //      DEFAULT_NIO_THREAD_COUNT = Runtime.getRuntime().availableProcessors() > 1    
  25. //              ? 2 * (Runtime.getRuntime().availableProcessors() - 1 ) : 2;    
  26.             
  27.         DEFAULT_NIO_THREAD_COUNT = 4;    
  28.     }    
  29.         
  30.     public SubReactorThreadGroup() {    
  31.         this(DEFAULT_NIO_THREAD_COUNT);    
  32.     }    
  33.         
  34.     public SubReactorThreadGroup(int threadCount) {    
  35.           
  36.         if(threadCount < 1) {    
  37.             threadCount = DEFAULT_NIO_THREAD_COUNT;    
  38.         }    
  39.           
  40.         businessExecutePool = Executors.newFixedThreadPool(threadCount);  
  41.           
  42.         this.nioThreadCount = threadCount;    
  43.         this.nioThreads = new SubReactorThread[threadCount];    
  44.         for(int i = 0; i < threadCount; i ++ ) {    
  45.             this.nioThreads[i] = new SubReactorThread(businessExecutePool);    
  46.             this.nioThreads[i].start(); //构造方法中启动线程，由于nioThreads不会对外暴露，故不会引起线程逃逸    
  47.         }    
  48.             
  49.         System.out.println("Nio 线程数量：" + threadCount);    
  50.     }    
  51.         
  52.     public void dispatch(SocketChannel socketChannel) {    
  53.         if(socketChannel != null ) {    
  54.             next().register(new NioTask(socketChannel, SelectionKey.OP_READ));    
  55.         }    
  56.     }    
  57.         
  58.     protected SubReactorThread next() {    
  59.         return this.nioThreads[ requestCounter.getAndIncrement() %  nioThreadCount ];    
  60.     }    
  61.         
  62.         
  63.     
  64.     public static void main(String[] args) {    
  65.         // TODO Auto-generated method stub    
  66.     
  67.     }    
  68.     
  69. }    
package persistent.prestige.demo.netty.threadmode.t3;

import java.nio.channels.SelectionKey;
import java.nio.channels.SocketChannel;  
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;  
  
/** 
 * nio 线程组;简易的NIO线程组 
 * @author dingwei2 
 * 
 */  
public class SubReactorThreadGroup {  
      
    private static final AtomicInteger requestCounter = new AtomicInteger();  //请求计数器  
      
    private final int nioThreadCount;  // 线程池IO线程的数量  
    private static final int DEFAULT_NIO_THREAD_COUNT;   
    private SubReactorThread[] nioThreads;  
    private ExecutorService businessExecutePool; //业务线程池
      
    static {  
//      DEFAULT_NIO_THREAD_COUNT = Runtime.getRuntime().availableProcessors() > 1  
//              ? 2 * (Runtime.getRuntime().availableProcessors() - 1 ) : 2;  
          
        DEFAULT_NIO_THREAD_COUNT = 4;  
    }  
      
    public SubReactorThreadGroup() {  
        this(DEFAULT_NIO_THREAD_COUNT);  
    }  
      
    public SubReactorThreadGroup(int threadCount) {  
    	
        if(threadCount < 1) {  
            threadCount = DEFAULT_NIO_THREAD_COUNT;  
        }  
        
        businessExecutePool = Executors.newFixedThreadPool(threadCount);
        
        this.nioThreadCount = threadCount;  
        this.nioThreads = new SubReactorThread[threadCount];  
        for(int i = 0; i < threadCount; i ++ ) {  
            this.nioThreads[i] = new SubReactorThread(businessExecutePool);  
            this.nioThreads[i].start(); //构造方法中启动线程，由于nioThreads不会对外暴露，故不会引起线程逃逸  
        }  
          
        System.out.println("Nio 线程数量：" + threadCount);  
    }  
      
    public void dispatch(SocketChannel socketChannel) {  
        if(socketChannel != null ) {  
            next().register(new NioTask(socketChannel, SelectionKey.OP_READ));  
        }  
    }  
      
    protected SubReactorThread next() {  
        return this.nioThreads[ requestCounter.getAndIncrement() %  nioThreadCount ];  
    }  
      
      
  
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
  
    }  
  
}

SubReactor线程实现（IO线程）

 

 

[java] view plain copy
 
print ?
  1. package persistent.prestige.demo.netty.threadmode.t3;  
  2.   
  3. import java.io.IOException;  
  4. import java.nio.ByteBuffer;  
  5. import java.nio.channels.SelectionKey;  
  6. import java.nio.channels.Selector;  
  7. import java.nio.channels.SocketChannel;  
  8. import java.util.ArrayList;  
  9. import java.util.Iterator;  
  10. import java.util.List;  
  11. import java.util.Set;  
  12. import java.util.concurrent.ExecutorService;  
  13. import java.util.concurrent.locks.ReentrantLock;  
  14.   
  15. /**  
  16.  * Nio 线程，专门负责nio read,write  
  17.  * 本类是实例行代码，不会对nio,断线重连，写半包等场景进行处理,旨在理解 Reactor模型（多线程版本）  
  18.  * @author dingwei2  
  19.  *  
  20.  */    
  21. public class SubReactorThread extends Thread {  
  22.   
  23.     private Selector selector;  
  24.     private ExecutorService businessExecutorPool;  
  25.     private List taskList = new ArrayList(512);  
  26.     private ReentrantLock taskMainLock = new ReentrantLock();  
  27.   
  28.     /** 
  29.      * 业务线程池 
  30.      * @param businessExecutorPool 
  31.      */  
  32.     public SubReactorThread(ExecutorService businessExecutorPool) {  
  33.         try {  
  34.             this.businessExecutorPool = businessExecutorPool;  
  35.             this.selector = Selector.open();  
  36.         } catch (IOException e) {  
  37.             // TODO Auto-generated catch block  
  38.             e.printStackTrace();  
  39.         }  
  40.     }  
  41.   
  42.     /** 
  43.      * socket channel 
  44.      *  
  45.      * @param socketChannel 
  46.      */  
  47.     public void register(NioTask task) {  
  48.         if (task != null) {  
  49.             try {  
  50.                 taskMainLock.lock();  
  51.                 taskList.add(task);  
  52.             } finally {  
  53.                 taskMainLock.unlock();  
  54.             }  
  55.         }  
  56.     }  
  57.   
  58.     // private  
  59.   
  60.     public void run() {  
  61.         while (!Thread.interrupted()) {  
  62.             Set ops = null;  
  63.             try {  
  64.                 selector.select(1000);  
  65.                 ops = selector.selectedKeys();  
  66.             } catch (IOException e) {  
  67.                 // TODO Auto-generated catch block  
  68.                 e.printStackTrace();  
  69.                 continue;  
  70.             }  
  71.   
  72.             // 处理相关事件  
  73.             for (Iterator it = ops.iterator(); it.hasNext();) {  
  74.                 SelectionKey key = it.next();  
  75.                 it.remove();  
  76.   
  77.                 try {  
  78.                     if (key.isWritable()) { // 向客户端发送请求  
  79.                         SocketChannel clientChannel = (SocketChannel) key  
  80.                                 .channel();  
  81.                         ByteBuffer buf = (ByteBuffer) key.attachment();  
  82.                         buf.flip();  
  83.                         clientChannel.write(buf);  
  84.                         System.out.println("服务端向客户端发送数据。。。");  
  85.                         // 重新注册读事件  
  86.                         clientChannel.register(selector, SelectionKey.OP_READ);  
  87.                     } else if (key.isReadable()) { // 接受客户端请求  
  88.                         System.out.println("服务端接收客户端连接请求。。。");  
  89.                         SocketChannel clientChannel = (SocketChannel) key  
  90.                                 .channel();  
  91.                         ByteBuffer buf = ByteBuffer.allocate(1024);  
  92.                         System.out.println(buf.capacity());  
  93.                         clientChannel.read(buf);//解析请求完毕  
  94.                           
  95.                         //转发请求到具体的业务线程；当然，这里其实可以向dubbo那样，支持转发策略，如果执行时间短，  
  96.                         //，比如没有数据库操作等，可以在io线程中执行。本实例，转发到业务线程池  
  97.                         dispatch(clientChannel, buf);  
  98.                           
  99.                     }  
  100.                 } catch (Throwable e) {  
  101.                     e.printStackTrace();  
  102.                     System.out.println("客户端主动断开连接。。。。。。。");  
  103.                 }  
  104.   
  105.             }  
  106.   
  107.             // 注册事件  
  108.             if (!taskList.isEmpty()) {  
  109.                 try {  
  110.                     taskMainLock.lock();  
  111.                     for (Iterator it = taskList  
  112.                             .iterator(); it.hasNext();) {  
  113.                         NioTask task = it.next();  
  114.                         try {  
  115.                             SocketChannel sc = task.getSc();  
  116.                             if(task.getData() != null) {  
  117.                                 sc.register(selector, task.getOp(), task.getData());  
  118.                             } else {  
  119.                                 sc.register(selector, task.getOp());  
  120.                             }  
  121.                               
  122.                         } catch (Throwable e) {  
  123.                             e.printStackTrace();// ignore  
  124.                         }  
  125.                         it.remove();  
  126.                     }  
  127.   
  128.                 } finally {  
  129.                     taskMainLock.unlock();  
  130.                 }  
  131.             }  
  132.   
  133.         }  
  134.     }  
  135.       
  136.     /** 
  137.      * 此处的reqBuffer处于可写状态 
  138.      * @param sc 
  139.      * @param reqBuffer 
  140.      */  
  141.     private void dispatch(SocketChannel sc, ByteBuffer reqBuffer) {  
  142.         businessExecutorPool.submit( new Handler(sc, reqBuffer, this)  );  
  143.     }  
  144. }  
package persistent.prestige.demo.netty.threadmode.t3;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.locks.ReentrantLock;

/** 
 * Nio 线程，专门负责nio read,write 
 * 本类是实例行代码，不会对nio,断线重连，写半包等场景进行处理,旨在理解 Reactor模型（多线程版本） 
 * @author dingwei2 
 * 
 */  
public class SubReactorThread extends Thread {

	private Selector selector;
	private ExecutorService businessExecutorPool;
	private List taskList = new ArrayList(512);
	private ReentrantLock taskMainLock = new ReentrantLock();

	/**
	 * 业务线程池
	 * @param businessExecutorPool
	 */
	public SubReactorThread(ExecutorService businessExecutorPool) {
		try {
			this.businessExecutorPool = businessExecutorPool;
			this.selector = Selector.open();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	/**
	 * socket channel
	 * 
	 * @param socketChannel
	 */
	public void register(NioTask task) {
		if (task != null) {
			try {
				taskMainLock.lock();
				taskList.add(task);
			} finally {
				taskMainLock.unlock();
			}
		}
	}

	// private

	public void run() {
		while (!Thread.interrupted()) {
			Set ops = null;
			try {
				selector.select(1000);
				ops = selector.selectedKeys();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				continue;
			}

			// 处理相关事件
			for (Iterator it = ops.iterator(); it.hasNext();) {
				SelectionKey key = it.next();
				it.remove();

				try {
					if (key.isWritable()) { // 向客户端发送请求
						SocketChannel clientChannel = (SocketChannel) key
								.channel();
						ByteBuffer buf = (ByteBuffer) key.attachment();
						buf.flip();
						clientChannel.write(buf);
						System.out.println("服务端向客户端发送数据。。。");
						// 重新注册读事件
						clientChannel.register(selector, SelectionKey.OP_READ);
					} else if (key.isReadable()) { // 接受客户端请求
						System.out.println("服务端接收客户端连接请求。。。");
						SocketChannel clientChannel = (SocketChannel) key
								.channel();
						ByteBuffer buf = ByteBuffer.allocate(1024);
						System.out.println(buf.capacity());
						clientChannel.read(buf);//解析请求完毕
						
						//转发请求到具体的业务线程；当然，这里其实可以向dubbo那样，支持转发策略，如果执行时间短，
						//，比如没有数据库操作等，可以在io线程中执行。本实例，转发到业务线程池
						dispatch(clientChannel, buf);
						
					}
				} catch (Throwable e) {
					e.printStackTrace();
					System.out.println("客户端主动断开连接。。。。。。。");
				}

			}

			// 注册事件
			if (!taskList.isEmpty()) {
				try {
					taskMainLock.lock();
					for (Iterator it = taskList
							.iterator(); it.hasNext();) {
						NioTask task = it.next();
						try {
							SocketChannel sc = task.getSc();
							if(task.getData() != null) {
								sc.register(selector, task.getOp(), task.getData());
							} else {
								sc.register(selector, task.getOp());
							}
							
						} catch (Throwable e) {
							e.printStackTrace();// ignore
						}
						it.remove();
					}

				} finally {
					taskMainLock.unlock();
				}
			}

		}
	}
	
	/**
	 * 此处的reqBuffer处于可写状态
	 * @param sc
	 * @param reqBuffer
	 */
	private void dispatch(SocketChannel sc, ByteBuffer reqBuffer) {
		businessExecutorPool.submit( new Handler(sc, reqBuffer, this)  );
	}
}

NioTask,NIO相关任务封装类：

 

 

[java] view plain copy
 
print ?
  1. package persistent.prestige.demo.netty.threadmode.t3;  
  2.   
  3. import java.io.Serializable;  
  4. import java.nio.channels.SocketChannel;  
  5.   
  6. /** 
  7.  * Nio task 
  8.  * @author Administrator 
  9.  * 
  10.  */  
  11. public class NioTask implements Serializable {  
  12.       
  13.     private SocketChannel sc;  
  14.     private int op;  
  15.     private Object data;  
  16.       
  17.     public NioTask(SocketChannel sc, int op) {  
  18.         this.sc = sc;  
  19.         this.op = op;  
  20.     }  
  21.       
  22.     public NioTask(SocketChannel sc, int op, Object data) {  
  23.         this(sc, op);  
  24.         this.data = data;  
  25.     }  
  26.     public SocketChannel getSc() {  
  27.         return sc;  
  28.     }  
  29.     public void setSc(SocketChannel sc) {  
  30.         this.sc = sc;  
  31.     }  
  32.     public int getOp() {  
  33.         return op;  
  34.     }  
  35.     public void setOp(int op) {  
  36.         this.op = op;  
  37.     }  
  38.     public Object getData() {  
  39.         return data;  
  40.     }  
  41.     public void setData(Object data) {  
  42.         this.data = data;  
  43.     }  
  44.       
  45.       
  46.   
  47. }  
package persistent.prestige.demo.netty.threadmode.t3;

import java.io.Serializable;
import java.nio.channels.SocketChannel;

/**
 * Nio task
 * @author Administrator
 *
 */
public class NioTask implements Serializable {
	
	private SocketChannel sc;
	private int op;
	private Object data;
	
	public NioTask(SocketChannel sc, int op) {
		this.sc = sc;
		this.op = op;
	}
	
	public NioTask(SocketChannel sc, int op, Object data) {
		this(sc, op);
		this.data = data;
	}
	public SocketChannel getSc() {
		return sc;
	}
	public void setSc(SocketChannel sc) {
		this.sc = sc;
	}
	public int getOp() {
		return op;
	}
	public void setOp(int op) {
		this.op = op;
	}
	public Object getData() {
		return data;
	}
	public void setData(Object data) {
		this.data = data;
	}
	
	

}
业务Handle类实现：

 

 

[java] view plain copy
 
print ?
  1. package persistent.prestige.demo.netty.threadmode.t3;  
  2.   
  3. import java.nio.ByteBuffer;  
  4. import java.nio.channels.SelectionKey;  
  5. import java.nio.channels.SocketChannel;  
  6.   
  7. /** 
  8.  * 业务线程 
  9.  * 该handler的功能就是在收到的请求信息，后面加上 hello,服务器收到了你的信息，然后返回给客户端 
  10.  * @author Administrator 
  11.  * 
  12.  */  
  13. public class Handler implements Runnable {  
  14.       
  15.     private static final byte[] b = "hello,服务器收到了你的信息。".getBytes(); // 服务端给客户端的响应  
  16.       
  17.     private SocketChannel sc;  
  18.     private ByteBuffer reqBuffer;  
  19.     private SubReactorThread parent;  
  20.       
  21.     public Handler(SocketChannel sc, ByteBuffer reqBuffer,  
  22.             SubReactorThread parent) {  
  23.         super();  
  24.         this.sc = sc;  
  25.         this.reqBuffer = reqBuffer;  
  26.         this.parent = parent;  
  27.     }  
  28.   
  29.     public void run() {  
  30.         System.out.println("业务在handler中开始执行。。。");  
  31.         // TODO Auto-generated method stub  
  32.         //业务处理  
  33.         reqBuffer.put(b);  
  34.         parent.register(new NioTask(sc, SelectionKey.OP_WRITE, reqBuffer));  
  35.         System.out.println("业务在handler中执行结束。。。");  
  36.     }  
  37.   
  38. }  
package persistent.prestige.demo.netty.threadmode.t3;

import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.SocketChannel;

/**
 * 业务线程
 * 该handler的功能就是在收到的请求信息，后面加上 hello,服务器收到了你的信息，然后返回给客户端
 * @author Administrator
 *
 */
public class Handler implements Runnable {
	
	private static final byte[] b = "hello,服务器收到了你的信息。".getBytes(); // 服务端给客户端的响应
	
	private SocketChannel sc;
	private ByteBuffer reqBuffer;
	private SubReactorThread parent;
	
	public Handler(SocketChannel sc, ByteBuffer reqBuffer,
			SubReactorThread parent) {
		super();
		this.sc = sc;
		this.reqBuffer = reqBuffer;
		this.parent = parent;
	}

	public void run() {
		System.out.println("业务在handler中开始执行。。。");
		// TODO Auto-generated method stub
		//业务处理
		reqBuffer.put(b);
		parent.register(new NioTask(sc, SelectionKey.OP_WRITE, reqBuffer));
		System.out.println("业务在handler中执行结束。。。");
	}

}

 

 

Nio客户端的实现，与上文一样。

 

注：本文代码旨在理解Reactor反应堆线程模型，对nio涉及到的断线重连，写半包等未做处理。本文关于Reactor模型的三个图片来源与网络，非原创，如果有侵权，请联系作者，将马上删除，谢谢。

你可能感兴趣的:(thread,多线程,java,设计模式)

  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • Java 重写(Override)与重载(Overload) 叨唧唧的
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
  • Java企业面试题3 马龙强_ java
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • 多线程之——ExecutorCompletionService 阿福德
    在我们开发中，经常会遇到这种情况，我们起多个线程来执行，等所有的线程都执行完成后，我们需要得到个线程的执行结果来进行聚合处理。我在内部代码评审时，发现了不少这种情况。看很多同学都使用正确，但比较啰嗦，效率也不高。本文介绍一个简单处理这种情况的方法：直接上代码：publicclassExecutorCompletionServiceTest{@TestpublicvoidtestExecutorCo
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • python多线程程序设计 之一 IT_Beijing_BIT #Python程序设计语言python
    python多线程程序设计之一全局解释器锁线程APIsthreading.active_count()threading.current_thread()threading.excepthook(args,/)threading.get_native_id()threading.main_thread()threading.stack_size([size])线程对象成员函数构造器start/ru
  • 白骑士的Java教学基础篇 2.5 控制流语句 白骑士所长 Java教学java开发语言
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
  • python语法——三目运算符 HappyRocking pythonpython三目运算符
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • Java：爬虫框架 dingcho Javajava爬虫
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
  • python怎么将png转为tif_png转tif weixin_39977276
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy） 跳房子的前端 前端面试javascript开发语言ecmascript
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
  • Python多线程实现大规模数据集高效转移 sand&wich 网络python服务器
    背景在处理大规模数据集时，通常需要在不同存储设备、不同服务器或文件夹之间高效地传输数据。如果采用单线程传输方式，当数据量非常大时，整个过程会非常耗时。因此，通过多线程并行处理可以大幅提升数据传输效率。本文将分享一个基于Python多线程实现的高效数据传输工具，通过遍历源文件夹中的所有文件，将它们移动到目标文件夹。工具和库这个数据集转移工具主要依赖于以下Python标准库：os：用于文件系统操作，如
  • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
  • Python实现下载当前年份的谷歌影像 sand&wich python开发语言
    在GIS项目和地图应用中，获取最新的地理影像数据是非常重要的。本文将介绍如何使用Python代码从Google地图自动下载当前年份的影像数据，并将其保存为高分辨率的TIFF格式文件。这个过程涉及地理坐标转换、多线程下载和图像处理。关键功能该脚本的核心功能包括：坐标转换：支持WGS-84与WebMercator投影之间转换，以及处理中国GCJ-02偏移。自动化下载：多线程下载地图瓦片，提高效率。图像
  • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
  • 博客网站制作教程 2401_85194651 javamaven
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
  • 桌面上有多个球在同时运动，怎么实现球之间不交叉，即碰撞？ 换个号韩国红果果 html小球碰撞
    稍微想了一下，然后解决了很多bug，最后终于把它实现了。其实原理很简单。在每改变一个小球的x y坐标后，遍历整个在dom树中的其他小球，看一下它们与当前小球的距离是否小于球半径的两倍？若小于说明下一次绘制该小球（设为a）前要把他的方向变为原来相反方向（与a要碰撞的小球设为b），即假如当前小球的距离小于球半径的两倍的话，马上改变当前小球方向。那么下一次绘制也是先绘制b，再绘制a，由于a的方向已经改变
  • 《高性能HTML5》读后整理的Web性能优化内容 白糖_ html5
    读后感         先说说《高性能HTML5》这本书的读后感吧，个人觉得这本书前两章跟书的标题完全搭不上关系，或者说只能算是讲解了“高性能”这三个字，HTML5完全不见踪影。个人觉得作者应该首先把HTML5的大菜拿出来讲一讲，再去分析性能优化的内容，这样才会有吸引力。因为只是在线试读，没有机会看后面的内容，所以不胡乱评价了。  
  • [JShop]Spring MVC的RequestContextHolder使用误区 dinguangx jeeshop商城系统jshop电商系统
        在spring mvc中，为了随时都能取到当前请求的request对象，可以通过RequestContextHolder的静态方法getRequestAttributes()获取Request相关的变量，如request, response等。         在jshop中，对RequestContextHolder的
  • 算法之时间复杂度 周凡杨 java算法时间复杂度效率
          在 计算机科学 中， 算法 的时间复杂度是一个 函数 ，它定量描述了该算法的运行时间。这是一个关于代表算法输入值的 字符串 的长度的函数。时间复杂度常用 大O符号 表述，不包括这个函数的低阶项和首项系数。使用这种方式时，时间复杂度可被称为是 渐近 的，它考察当输入值大小趋近无穷时的情况。 这样用大写O()来体现算法时间复杂度的记法，
  • Java事务处理 g21121 java
    一、什么是Java事务 通常的观念认为，事务仅与数据库相关。 事务必须服从ISO/IEC所制定的ACID原则。ACID是原子性（atomicity）、一致性（consistency）、隔离性（isolation）和持久性（durability）的缩写。事务的原子性表示事务执行过程中的任何失败都将导致事务所做的任何修改失效。一致性表示当事务执行失败时，所有被该事务影响的数据都应该恢复到事务执行前的状
  • Linux awk命令详解 510888780 linux
    一.  AWK 说明   awk是一种编程语言，用于在linux/unix下对文本和数据进行处理。数据可以来自标准输入、一个或多个文件，或其它命令的输出。它支持用户自定义函数和动态正则表达式等先进功能，是linux/unix下的一个强大编程工具。它在命令行中使用，但更多是作为脚本来使用。    awk的处理文本和数据的方式：它逐行扫描文件，从第一行到
  • android permission 布衣凌宇 Permission
    <uses-permission android:name="android.permission.ACCESS_CHECKIN_PROPERTIES" ></uses-permission>允许读写访问"properties"表在checkin数据库中，改值可以修改上传 <uses-permission android:na
  • Oracle和谷歌Java Android官司将推迟 aijuans javaoracle
    北京时间 10 月 7 日，据国外媒体报道，Oracle 和谷歌之间一场等待已久的官司可能会推迟至 10 月 17 日以后进行，这场官司的内容是 Android 操作系统所谓的 Java 专利权之争。本案法官 William Alsup 称根据专利权专家 Florian Mueller 的预测，谷歌 Oracle 案很可能会被推迟。　　该案中的第二波辩护被安排在 10 月 17 日出庭，从目前看来
  • linux shell 常用命令 antlove linuxshellcommand
    grep [options] [regex] [files] /var/root # grep -n "o" * hello.c:1:/* This C source can be compiled with:
  • Java解析XML配置数据库连接(DOM技术连接 SAX技术连接) 百合不是茶 sax技术Java解析xml文档dom技术XML配置数据库连接
        XML配置数据库文件的连接其实是个很简单的问题,为什么到现在才写出来主要是昨天在网上看了别人写的,然后一直陷入其中,最后发现不能自拔 所以今天决定自己完成 ,,,,现将代码与思路贴出来供大家一起学习   XML配置数据库的连接主要技术点的博客; JDBC编程 : JDBC连接数据库 DOM解析XML:  DOM解析XML文件 SA
  • underscore.js 学习（二） bijian1013 JavaScriptunderscore
            Array Functions 所有数组函数对参数对象一样适用。1.first   _.first(array, [n])   别名: head, take       返回array的第一个元素，设置了参数n，就
  • plSql介绍 bijian1013 oracle数据库plsql
    /* * PL/SQL 程序设计学习笔记 * 学习plSql介绍.pdf * 时间：2010-10-05 */ --创建DEPT表 create table DEPT ( DEPTNO NUMBER(10), DNAME NVARCHAR2(255), LOC NVARCHAR2(255) ) delete dept; select
  • 【Nginx一】Nginx安装与总体介绍 bit1129 nginx
    启动、停止、重新加载Nginx nginx 启动Nginx服务器，不需要任何参数u nginx -s stop 快速(强制)关系Nginx服务器 nginx -s quit 优雅的关闭Nginx服务器 nginx -s reload 重新加载Nginx服务器的配置文件 nginx -s reopen 重新打开Nginx日志文件  
  • spring mvc开发中浏览器兼容的奇怪问题 bitray jqueryAjaxspringMVC浏览器上传文件
        最近个人开发一个小的OA项目,属于复习阶段.使用的技术主要是spring mvc作为前端框架,mybatis作为数据库持久化技术.前台使用jquery和一些jquery的插件.     在开发到中间阶段时候发现自己好像忽略了一个小问题,整个项目一直在firefox下测试,没有在IE下测试,不确定是否会出现兼容问题.由于jquer
  • Lua的io库函数列表 ronin47 lua io
    1、io表调用方式：使用io表，io.open将返回指定文件的描述，并且所有的操作将围绕这个文件描述 　　io表同样提供三种预定义的文件描述io.stdin,io.stdout,io.stderr 　　2、文件句柄直接调用方式,即使用file:XXX()函数方式进行操作,其中file为io.open()返回的文件句柄 　　多数I/O函数调用失败时返回nil加错误信息,有些函数成功时返回nil
  • java-26-左旋转字符串 bylijinnan java
    public class LeftRotateString { /** * Q 26 左旋转字符串 * 题目：定义字符串的左旋转操作：把字符串前面的若干个字符移动到字符串的尾部。 * 如把字符串abcdef左旋转2位得到字符串cdefab。 * 请实现字符串左旋转的函数。要求时间对长度为n的字符串操作的复杂度为O(n)，辅助内存为O(1)。 */ pu
  • 《vi中的替换艺术》-linux命令五分钟系列之十一 cfyme linux命令
    vi方面的内容不知道分类到哪里好，就放到《Linux命令五分钟系列》里吧！ 今天编程，关于栈的一个小例子，其间我需要把”S.”替换为”S->”(替换不包括双引号)。 其实这个不难，不过我觉得应该总结一下vi里的替换技术了，以备以后查阅。   1 所有替换方案都要在冒号“:”状态下书写。 2 如果想将abc替换为xyz，那么就这样 :s/abc/xyz/ 不过要特别
  • [轨道与计算]新的并行计算架构 comsci 并行计算
         我在进行流程引擎循环反馈试验的过程中，发现一个有趣的事情。。。如果我们在流程图的每个节点中嵌入一个双向循环代码段，而整个流程中又充满着很多并行路由，每个并行路由中又包含着一些并行节点，那么当整个流程图开始循环反馈过程的时候，这个流程图的运行过程是否变成一个并行计算的架构呢？      
  • 重复执行某段代码 dai_lm android
    用handler就可以了 private Handler handler = new Handler(); private Runnable runnable = new Runnable() { public void run() { update(); handler.postDelayed(this, 5000); } }; 开始计时 h
  • Java实现堆栈（list实现） datageek 数据结构——堆栈
    public interface IStack<T> { //元素出栈，并返回出栈元素 public T pop(); //元素入栈 public void push(T element); //获取栈顶元素 public T peek(); //判断栈是否为空 public boolean isEmpty
  • 四大备份MySql数据库方法及可能遇到的问题 dcj3sjt126com DBbackup
    一：通过备份王等软件进行备份前台进不去？ 用备份王等软件进行备份是大多老站长的选择，这种方法方便快捷，只要上传备份软件到空间一步步操作就可以，但是许多刚接触备份王软件的客用户来说还原后会出现一个问题：因为新老空间数据库用户名和密码不统一，网站文件打包过来后因没有修改连接文件，还原数据库是好了，可是前台会提示数据库连接错误，网站从而出现打不开的情况。 解决方法：学会修改网站配置文件，大多是由co
  • github做webhooks：[1]钩子触发是否成功测试 dcj3sjt126com githubgitwebhook
    转自: http://jingyan.baidu.com/article/5d6edee228c88899ebdeec47.html github和svn一样有钩子的功能，而且更加强大。例如我做的是最常见的push操作触发的钩子操作，则每次更新之后的钩子操作记录都会在github的控制板可以看到！ 工具/原料 github 方法/步骤
  • ">的作用" target="_blank">JSP中的作用 蕃薯耀
    JSP中<base href="<%=basePath%>">的作用 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  • linux下SAMBA服务安装与配置 hanqunfeng linux
    局域网使用的文件共享服务。 一.安装包： rpm -qa | grep samba samba-3.6.9-151.el6.x86_64 samba-common-3.6.9-151.el6.x86_64 samba-winbind-3.6.9-151.el6.x86_64 samba-client-3.6.9-151.el6.x86_64 samba-winbind-clients
  • guava cache IXHONG cache
    缓存，在我们日常开发中是必不可少的一种解决性能问题的方法。简单的说，cache 就是为了提升系统性能而开辟的一块内存空间。 　　缓存的主要作用是暂时在内存中保存业务系统的数据处理结果，并且等待下次访问使用。在日常开发的很多场合，由于受限于硬盘IO的性能或者我们自身业务系统的数据处理和获取可能非常费时，当我们发现我们的系统这个数据请求量很大的时候，频繁的IO和频繁的逻辑处理会导致硬盘和CPU资源的
  • Query的开始--全局变量,noconflict和兼容各种js的初始化方法 kvhur JavaScriptjquerycss
    这个是整个jQuery代码的开始，里面包含了对不同环境的js进行的处理，例如普通环境，Nodejs，和requiredJs的处理方法。 还有jQuery生成$, jQuery全局变量的代码和noConflict代码详解  完整资源： http://www.gbtags.com/gb/share/5640.htm jQuery 源码：   (
  • 美国人的福利和中国人的储蓄 nannan408
       今天看了篇文章，震动很大，说的是美国的福利。    美国医院的无偿入院真的是个好措施。小小的改善，对于社会是大大的信心。小孩，税费等，政府不收反补，真的体现了人文主义。    美国这么高的社会保障会不会使人变懒？答案是否定的。正因为政府解决了后顾之忧，人们才得以倾尽精力去做一些有创造力，更造福社会的事情，这竟成了美国社会思想、人
  • N阶行列式计算(JAVA) qiuwanchi N阶行列式计算
    package gaodai; import java.util.List; /** * N阶行列式计算 * @author 邱万迟 * */ public class DeterminantCalculation { public DeterminantCalculation(List<List<Double>> determina
  • C语言算法之打渔晒网问题 qiufeihu c算法
    如果一个渔夫从2011年1月1日开始每三天打一次渔，两天晒一次网，编程实现当输入2011年1月1日以后任意一天，输出该渔夫是在打渔还是在晒网。 代码如下：   #include <stdio.h> int leap(int a) /*自定义函数leap()用来指定输入的年份是否为闰年*/ { if((a%4 == 0 && a%100 != 0
  • XML中DOCTYPE字段的解析 wyzuomumu xml
    DTD声明始终以!DOCTYPE开头,空一格后跟着文档根元素的名称,如果是内部DTD,则再空一格出现[],在中括号中是文档类型定义的内容. 而对于外部DTD,则又分为私有DTD与公共DTD,私有DTD使用SYSTEM表示,接着是外部DTD的URL. 而公共DTD则使用PUBLIC,接着是DTD公共名称,接着是DTD的URL.   私有DTD <!DOCTYPErootSYST
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他