经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Java » 查看文章
java核心技术-NIO
来源：cnblogs　　作者：我是派大星　　时间：2018/11/7 0:44:53　　对本文有异议

1、reactor（反应器）模式

　　使用单线程模拟多线程，提高资源利用率和程序的效率，增加系统吞吐量。下面例子比较形象的说明了什么是反应器模式：

　　一个老板经营一个饭店，

　　传统模式 - 来一个客人安排一个服务员招呼，客人很满意；（相当于一个连接一个线程）

　　后来客人越来越多，需要的服务员越来越多，资源条件不足以再请更多的服务员了，传统模式已经不能满足需求。老板之所以为老板自然有过人之处，老板发现，服务员在为客人服务时，当客人点菜的时候，服务员基本处于等待状态，（阻塞线程，不做事）。

　　于是乎就让服务员在客人点菜的时候，去为其他客人服务，当客人菜点好后再招呼服务员即可。 --反应器（reactor）模式诞生了

　　饭店的生意红红火火，几个服务员就足以支撑大量的客流量，老板用有限的资源赚了更多的money~~~~_

　通道：类似于流，但是可以异步读写数据（流只能同步读写），通道是双向的，（流是单向的），通道的数据总是要先读到一个buffer 或者 从一个buffer写入，即通道与buffer进行数据交互。

　　

通道类型：　　

  • FileChannel：从文件中读写数据。　　
  • DatagramChannel：能通过UDP读写网络中的数据。　　
  • SocketChannel：能通过TCP读写网络中的数据。　　
  • ServerSocketChannel：可以监听新进来的TCP连接，像Web服务器那样。对每一个新进来的连接都会创建一个SocketChannel。　　

　-　FileChannel比较特殊，它可以与通道进行数据交互， 不能切换到非阻塞模式，套接字通道可以切换到非阻塞模式；

缓冲区 - 本质上是一块可以存储数据的内存，被封装成了buffer对象而已！

　　

缓冲区类型：

  • ByteBuffer　　
  • MappedByteBuffer　　
  • CharBuffer　　
  • DoubleBuffer　　
  • FloatBuffer　　
  • IntBuffer　　
  • LongBuffer　　
  • ShortBuffer　　

常用方法：

  • allocate() - 分配一块缓冲区　　
  • put() - 向缓冲区写数据
  • get() - 向缓冲区读数据　　
  • filp() - 将缓冲区从写模式切换到读模式　　
  • clear() - 从读模式切换到写模式，不会清空数据，但后续写数据会覆盖原来的数据，即使有部分数据没有读，也会被遗忘；　　
  • compact() - 从读数据切换到写模式，数据不会被清空，会将所有未读的数据copy到缓冲区头部，后续写数据不会覆盖，而是在这些数据之后写数据
  • mark() - 对position做出标记，配合reset使用
  • reset() - 将position置为标记值　　　　

缓冲区的一些属性：

  • capacity - 缓冲区大小，无论是读模式还是写模式，此属性值不会变；

  • position - 写数据时，position表示当前写的位置，每写一个数据，会向下移动一个数据单元，初始为0；最大为capacity - 1，切换到读模式时，position会被置为0，表示当前读的位置

  • limit - 写模式下，limit 相当于capacity 表示最多可以写多少数据，切换到读模式时，limit 等于原先的position，表示最多可以读多少数据。

非直接缓冲区：通过allocate() 方法 分配缓冲区,将缓冲区建立在JVM内存中

直接缓冲区：通过allocateDirect() 方法直接缓冲区 将缓冲区建立在物理内存中

2.1 关于缓冲区各个属性的测试

  1. 	    String str = "abcde";
  2. 		
  3. 		//1. 分配一个指定大小的缓冲区
  4. 		ByteBuffer buf = ByteBuffer.allocate(1024);
  5. 		
  6. 		System.out.println("--------------allocate()----------------");
  7. 		System.out.println(buf.position());//0
  8. 		System.out.println(buf.limit());//1024
  9. 		System.out.println(buf.capacity());//1024
  10. 		
  11. 		//2. 利用put存入数据到缓冲区中去
  12. 		buf.put(str.getBytes());
  13. 		
  14. 		System.out.println("----------------put()-------------------");
  15. 		System.out.println(buf.position());//5
  16. 		System.out.println(buf.limit());//1024
  17. 		System.out.println(buf.capacity());//1024
  19. 		
  20. 		//3. 切换到读取模式
  21. 		buf.flip();
  22. 		
  23. 		System.out.println("----------------flip()------------------");
  24. 		System.out.println(buf.position());//0
  25. 		System.out.println(buf.limit());//5
  26. 		System.out.println(buf.capacity());//1024
  28. 		
  29. 		//4. 利用get() 读取缓冲区中的数据
  30. 		byte[] dst = new byte[buf.limit()];
  31. 		buf.get(dst);
  32. 		System.out.println(new String(dst,0,dst.length));
  33. 		
  34. 		System.out.println("----------------get()------------------");
  35. 		System.out.println(buf.position());//5
  36. 		System.out.println(buf.limit());//5
  37. 		System.out.println(buf.capacity());//1024
  39. 		
  40. 		//5.可重复读
  41. 		buf.rewind();
  42. 		
  43. 		System.out.println("----------------rewind()------------------");
  44. 		System.out.println(buf.position());//0
  45. 		System.out.println(buf.limit());//5
  46. 		System.out.println(buf.capacity());//1024
  48. 		
  49. 		//6.clear(): 清空缓冲区, 但是缓冲区的数据依然存在, 但是处于被遗忘的状态
  50. 		buf.clear();
  51. 		
  52. 		System.out.println("----------------clear()-------------------");
  53. 		System.out.println(buf.position());//0
  54. 		System.out.println(buf.limit());//1024
  55. 		System.out.println(buf.capacity());//1024
  57. 		byte[] newByte = new byte[buf.limit()];
  58. 		buf.get(newByte);
  59. 		System.out.println(new String(newByte,0,newByte.length));

2.2 关于通道的使用

1.利用通道进行 文件的复制 非直接缓冲区

  2. 		FileInputStream fis = null;
  3. 		FileOutputStream fos = null;
  4. 		FileChannel inChannel = null;
  5. 		FileChannel outChannel = null;
  6. 		try {
  7. 			fis = new FileInputStream("1.jpg");
  8. 			fos = new FileOutputStream("2.jpg");
  10. 			// ①获取通道
  11. 			inChannel = fis.getChannel();
  12. 			outChannel = fos.getChannel();
  14. 			// ②将通道中的数据存入缓冲区
  15. 			ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
  17. 			// 将通道中的数据存入缓冲区
  18. 			while (inChannel.read(byteBuffer) != -1) {
  19. 				byteBuffer.flip(); // 切换读取数据的模式
  20. 				outChannel.write(byteBuffer);
  21. 				byteBuffer.clear();
  22. 			}
  24. 		} catch (IOException e) {
  25. 			e.printStackTrace();
  26. 		} finally {
  27. 			if (inChannel != null) {
  28. 				try {
  29. 					inChannel.close();
  30. 				} catch (IOException e) {
  31. 					e.printStackTrace();
  32. 				}
  33. 			}
  35. 			if (outChannel != null) {
  36. 				try {
  37. 					outChannel.close();
  38. 				} catch (IOException e) {
  39. 					e.printStackTrace();
  40. 				}
  41. 			}
  43. 			if (fis != null) {
  44. 				try {
  45. 					fis.close();
  46. 				} catch (IOException e) {
  47. 					e.printStackTrace();
  48. 				}
  49. 			}
  51. 			if (fos != null) {
  52. 				try {
  53. 					fos.close();
  54. 				} catch (IOException e) {
  55. 					e.printStackTrace();
  56. 				}
  57. 			}
  59. 		}
  60.

2.通道之间的传输

CREATE_NEW：如果文件不存在就创建，存在就报错

CREATE：如果文件不存在就创建，存在创建(覆盖)

  2. 		FileChannel inChannel = null;
  3. 		FileChannel outChannel = null;
  4. 		try {
  5. 			inChannel = FileChannel.open(Paths.get("hello.txt"), StandardOpenOption.READ);
  6. 			outChannel = FileChannel.open(Paths.get("hello2.txt"), StandardOpenOption.READ,StandardOpenOption.WRITE,StandardOpenOption.CREATE_NEW);
  7. 			
  8. 			inChannel.transferTo(0, inChannel.size(), outChannel);
  9. 		} catch (Exception e) {
  10. 			e.printStackTrace();
  11. 		}  finally {
  12. 			
  13. 			if(inChannel != null){
  14. 				try {
  15. 					inChannel.close();
  16. 				} catch (IOException e) {
  17. 					e.printStackTrace();
  18. 				}
  19. 			}
  20. 			
  21. 			if(outChannel != null){
  22. 				try {
  23. 					outChannel.close();
  24. 				} catch (IOException e) {
  25. 					e.printStackTrace();
  26. 				}
  27. 			}
  28. 		}
  29.

3. 使用直接缓冲区完成内存文件的复制

  1. 		FileChannel inChannel = null;
  2. 		FileChannel outChannel = null;
  3. 		try {
  4. 			inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);
  5. 			outChannel = FileChannel.open(Paths.get("x.jpg"), StandardOpenOption.READ,StandardOpenOption.WRITE,StandardOpenOption.CREATE_NEW);
  6. 			
  7. 			MappedByteBuffer inMappedBuffer = inChannel.map(MapMode.READ_ONLY, 0, inChannel.size());
  8. 			MappedByteBuffer outMappedBuffer = outChannel.map(MapMode.READ_WRITE, 0, inChannel.size());
  9. 			
  10. 			System.out.println(inMappedBuffer.limit());
  11. 			byte[] b = new byte[inMappedBuffer.limit()];;
  12. 			inMappedBuffer.get(b);
  13. 			outMappedBuffer.put(b);
  14. 			
  15. 		} catch (Exception e) {
  16. 			e.printStackTrace();
  17. 		} finally {
  18. 			
  19. 			if(inChannel != null){
  20. 				try {
  21. 					inChannel.close();
  22. 				} catch (IOException e) {
  23. 					e.printStackTrace();
  24. 				}
  25. 			}
  26. 			
  27. 			if(outChannel != null){
  28. 				try {
  29. 					outChannel.close();
  30. 				} catch (IOException e) {
  31. 					e.printStackTrace();
  32. 				}
  33. 			}
  34. 			
  35. 		}

2.3 重点 NIO-非阻塞IO

个人认为 NIO 最难的两点 一个是对于选择器和选择键的理解 其次是对于网络通信模型的理解

本章内容以防过长 只讲解 NIO 的使用方法 上述两点参看下回分解

阻塞IO示例：

  1. 	//客户端
  2. 	@Test
  3. 	public void client() throws IOException{
  4. 		SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
  5. 		
  6. 		FileChannel inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);
  7. 		
  8. 		ByteBuffer buf = ByteBuffer.allocate(1024);
  9. 		
  10. 		while(inChannel.read(buf) != -1){
  11. 			buf.flip();
  12. 			sChannel.write(buf);
  13. 			buf.clear();
  14. 		}
  15. 		
  16. 		sChannel.shutdownOutput();
  17. 		
  18. 		//接收服务端的反馈
  19. 		int len = 0;
  20. 		while((len = sChannel.read(buf)) != -1){
  21. 			buf.flip();
  22. 			System.out.println(new String(buf.array(), 0, len));
  23. 			buf.clear();
  24. 		}
  25. 		
  26. 		inChannel.close();
  27. 		sChannel.close();
  28. 	}
  29. 	
  30. 	//服务端
  31. 	@Test
  32. 	public void server() throws IOException{
  33. 		ServerSocketChannel ssChannel = ServerSocketChannel.open();
  34. 		
  35. 		FileChannel outChannel = FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);
  36. 		
  37. 		ssChannel.bind(new InetSocketAddress(9898));
  38. 		
  39. 		SocketChannel sChannel = ssChannel.accept();
  40. 		
  41. 		ByteBuffer buf = ByteBuffer.allocate(1024);
  42. 		
  43. 		while(sChannel.read(buf) != -1){
  44. 			buf.flip();
  45. 			outChannel.write(buf);
  46. 			buf.clear();
  47. 		}
  48. 		
  49. 		//发送反馈给客户端
  50. 		buf.put("服务端接收数据成功".getBytes());
  51. 		buf.flip();
  52. 		sChannel.write(buf);
  53. 		
  54. 		sChannel.close();
  55. 		outChannel.close();
  56. 		ssChannel.close();
  57. 	}

非阻塞IO示例-TCP:

  1. //客户端
  2. 	@Test
  3. 	public void client() throws IOException{
  4. 		//1. 获取通道
  5. 		SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
  6. 		
  7. 		//2. 切换非阻塞模式
  8. 		sChannel.configureBlocking(false);
  9. 		
  10. 		//3. 分配指定大小的缓冲区
  11. 		ByteBuffer buf = ByteBuffer.allocate(1024);
  12. 		
  13. 		//4. 发送数据给服务端
  14. 		Scanner scan = new Scanner(System.in);
  15. 		
  16. 		while(scan.hasNext()){
  17. 			String str = scan.next();
  18. 			buf.put((new Date().toString() + "\n" + str).getBytes());
  19. 			buf.flip();
  20. 			sChannel.write(buf);
  21. 			buf.clear();
  22. 		}
  23. 		
  24. 		//5. 关闭通道
  25. 		sChannel.close();
  26. 	}
  28. 	//服务端
  29. 	@Test
  30. 	public void server() throws IOException{
  31. 		//1. 获取通道
  32. 		ServerSocketChannel ssChannel = ServerSocketChannel.open();
  33. 		
  34. 		//2. 切换非阻塞模式
  35. 		ssChannel.configureBlocking(false);
  36. 		
  37. 		//3. 绑定连接
  38. 		ssChannel.bind(new InetSocketAddress(9898));
  39. 		
  40. 		//4. 获取选择器
  41. 		Selector selector = Selector.open();
  42. 		
  43. 		//5. 将通道注册到选择器上, 并且指定“监听接收事件”
  44. 		ssChannel.register(selector, SelectionKey.OP_ACCEPT);
  45. 		
  46. 		//6. 轮询式的获取选择器上已经“准备就绪”的事件
  47. 		while(selector.select() > 0){
  48. 			
  49. 			//7. 获取当前选择器中所有注册的“选择键(已就绪的监听事件)”
  50. 			Iterator<SelectionKey> it = selector.selectedKeys().iterator();
  51. 			
  52. 			while(it.hasNext()){
  53. 				//8. 获取准备“就绪”的是事件
  54. 				SelectionKey sk = it.next();
  55. 				
  56. 				//9. 判断具体是什么事件准备就绪
  57. 				if(sk.isAcceptable()){
  58. 					//10. 若“接收就绪”，获取客户端连接
  59. 					SocketChannel sChannel = ssChannel.accept();
  60. 					
  61. 					//11. 切换非阻塞模式
  62. 					sChannel.configureBlocking(false);
  63. 					
  64. 					//12. 将该通道注册到选择器上
  65. 					sChannel.register(selector, SelectionKey.OP_READ);
  66. 				}else if(sk.isReadable()){
  67. 					//13. 获取当前选择器上“读就绪”状态的通道
  68. 					SocketChannel sChannel = (SocketChannel) sk.channel();
  69. 					
  70. 					//14. 读取数据
  71. 					ByteBuffer buf = ByteBuffer.allocate(1024);
  72. 					
  73. 					int len = 0;
  74. 					while((len = sChannel.read(buf)) > 0 ){
  75. 						buf.flip();
  76. 						System.out.println(new String(buf.array(), 0, len));
  77. 						buf.clear();
  78. 					}
  79. 				}
  80. 				
  81. 				//15. 取消选择键 SelectionKey
  82. 				it.remove();
  83. 			}
  84. 		}
  85. 	}

非阻塞IO示例-UDP:

  1. 	@Test
  2. 	public void send() throws IOException{
  3. 		DatagramChannel dc = DatagramChannel.open();
  4. 		
  5. 		dc.configureBlocking(false);
  6. 		
  7. 		ByteBuffer buf = ByteBuffer.allocate(1024);
  8. 		
  9. 		Scanner scan = new Scanner(System.in);
  10. 		
  11. 		while(scan.hasNext()){
  12. 			String str = scan.next();
  13. 			buf.put((new Date().toString() + ":\n" + str).getBytes());
  14. 			buf.flip();
  15. 			dc.send(buf, new InetSocketAddress("127.0.0.1", 9898));
  16. 			buf.clear();
  17. 		}
  18. 		
  19. 		dc.close();
  20. 	}
  21. 	
  22. 	@Test
  23. 	public void receive() throws IOException{
  24. 		DatagramChannel dc = DatagramChannel.open();
  25. 		
  26. 		dc.configureBlocking(false);
  27. 		
  28. 		dc.bind(new InetSocketAddress(9898));
  29. 		
  30. 		Selector selector = Selector.open();
  31. 		
  32. 		dc.register(selector, SelectionKey.OP_READ);
  33. 		
  34. 		while(selector.select() > 0){
  35. 			Iterator<SelectionKey> it = selector.selectedKeys().iterator();
  36. 			
  37. 			while(it.hasNext()){
  38. 				SelectionKey sk = it.next();
  39. 				
  40. 				if(sk.isReadable()){
  41. 					ByteBuffer buf = ByteBuffer.allocate(1024);
  42. 					
  43. 					dc.receive(buf);
  44. 					buf.flip();
  45. 					System.out.println(new String(buf.array(), 0, buf.limit()));
  46. 					buf.clear();
  47. 				}
  48. 			}
  49. 			
  50. 			it.remove();
  51. 		}
  52. 	}
 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Java热门文章

  • 【IDEA】Application context not configured for this file
  • [IDEA] chapter_reader - idea看小说插件 idea阅读插件 idea摸鱼插件
  • thrift常见异常及原因分析
  • Java 调用 PaddleDetection 模型
  • JVM 详解，大白话带你认识 JVM
  • spring-boot-2.0.3不一样系列之番外篇 - @Configuration、Condition与@Conditional
  • Java Comparator.comparing比较导致空指针异常的解决
  • Java使用EasyExcel进行单元格合并的问题详解
  • 死磕 java集合之ArrayBlockingQueue源码分析
  • Java基础之集合Set详解

    • Java推荐文章

  • 面试场景题：一次关于线程池使用场景的讨论。
  • 前端黑科技：使用 JavaScript 实现网页扫码功能
  • 聊一聊 Netty 数据搬运工 ByteBuf 体系的设计与实现
  • 简单设计一个JAVA并行处理工具类
  • 【杂谈】JPA乐观锁改悲观锁遇到的一些问题与思考
  • 认识netty的基本组件
  • Jenkins如何使用CrumbIssuer防御CSRF攻击
  • 如何平稳地从nacos迁移到r-nacos？
  • 线程池遇到父子任务，有大坑，要注意！
  • Java JVM——12. 垃圾回收理论概述

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号