Java Socket实现NIO通信

最新推荐文章于 2024-07-30 07:15:00 发布
最新推荐文章于 2024-07-30 07:15:00 发布
阅读量2.4k 收藏 12
点赞数 4
分类专栏： 计算机网络 文章标签： java nio 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangliangluang/article/details/128425224
版权

文章目录

一.简单介绍

      NIO 很多人也称之为 Non-block I/O，即非阻塞 I/O，因为这样叫，更能体现它的特点。

为什么这么说呢？传统的 I/O 存在阻塞问题。因为对 Socket 的输入流进行读取时，读取流会一直阻塞，直到发生以下三种情况的任意一种才会解除阻塞：

  • 有数据可读；
  • 连接释放；
  • 空指针或 I/O 异常。

阻塞问题，就是传统 I/O 最大的弊端。

NIO 发布后，通道和多路复用器这两个基本组件实现了 NIO 的非阻塞，下面我们就一起来了解下这两个组件的优化原理。

通道（Channel）

      传统 I/O 的数据读取和写入是从用户空间到内核空间来回复制，而内核空间的数据是通过操作系统层面的 I/O 接口从磁盘读取或写入。

      最开始，在应用程序调用操作系统 I/O 接口时，是由 CPU 完成分配，这种方式最大的问题是“发生大量 I/O 请求时，非常消耗 CPU“；之后，操作系统引入了 DMA（直接存储器存储），内核空间与磁盘之间的存取完全由 DMA 负责，但这种方式依然需要向 CPU 申请权限，且需要借助 DMA 总线来完成数据的复制操作，如果 DMA 总线过多，就会造成总线冲突。

      通道的出现解决了以上问题，Channel 有自己的处理器，就是在DMA的基础上增加了能执行有限通道指令的I/O控制器，代替CPU管理控制外设.它有自己的指令系统，是一个协处理器，他实质能够执行有限的输入输出指令,并且由专门通讯传输的通道总线完成控制.

      所以,Channel可以完成内核空间和磁盘之间的 I/O 操作。在 NIO 中，我们读取和写入数据都要通过 Channel，由于 Channel 是双向的，所以读、写可以同时进行。

多路复用器（Selector）

      Selector 是 Java NIO 编程的基础。用于检查一个或多个 NIO Channel 的状态是否处于可读、可写。

      Selector 是基于事件驱动实现的，我们可以在 Selector 中注册 accpet、read 监听事件，Selector 会不断轮询注册在其上的 Channel，如果某个 Channel 上面发生监听事件，这个 Channel 就处于就绪状态，然后进行 I/O 操作。

      一个线程使用一个 Selector，通过轮询的方式，可以监听多个 Channel 上的事件。我们可以在注册 Channel 时设置该通道为非阻塞，当 Channel 上没有 I/O 操作时，该线程就不会一直等待了，而是会不断轮询所有 Channel，从而避免发生阻塞。

      目前操作系统的 I/O 多路复用机制都使用了 epoll，相比传统的 select 机制，epoll 没有最大连接句柄 1024 的限制。所以 Selector 在理论上可以轮询成千上万的客户端。

二.代码实现.

总共涉及四个类,以下代码可以直接拿去用

在这里插入图片描述

消息得大概处理流程是这样得:

  1. 创建Channel,监听连接
  2. 创建多路复用器Selector,将Channel注册到Selector中
  3. Selector去轮询所有注册在其上的channel,当发现一个或多个就绪时,返回就绪的监听事件
  4. 程序匹配到监听事件,进行处理

这里扩充一下细节,在将Channel注册到Selector中时,需要指定监听事件,这个监听事件正好对应Socket通信中的 conect、accept、read 、write 几个阻塞操作.
在这里插入图片描述

客户端

Client 类.

import java.util.Scanner;

public class Client {

	private static String DEFAULT_HOST = "127.0.0.1";  
	
    private static int DEFAULT_PORT = 8081;  
	
    private static ClientHandler clientHandler;  
	
    public static void start(){  
        start(DEFAULT_HOST,DEFAULT_PORT);  
    }  
	
    public static synchronized void start(String ip,int port){  
	 
        clientHandler = new ClientHandler(ip,port);  
        new Thread(clientHandler,"Server").start();  
	 
    }  
	
    //向服务器发送消息  
    public static boolean sendMsg(String msg) throws Exception{  
        clientHandler.sendMsg(msg);  
        return true;  
	
    } 
    
	@SuppressWarnings("resource")
	public static void main(String[] args) {

		// 运行客户端
		Client.start();

		try {
			while (Client.sendMsg(new Scanner(System.in).nextLine()));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}


}

ClientHandler类.

public class ClientHandler implements Runnable {

	private SocketChannel socketChannel;
	private int port;
	private Selector selector;
	private String host;
	private boolean stop;

	public ClientHandler(String host, int port) {

		this.host = host;
		this.port = port;

		try {
			selector = Selector.open();
			socketChannel = SocketChannel.open();
			socketChannel.configureBlocking(false);

		} catch (IOException e) {
			e.printStackTrace();
			System.exit(1);
		}

	}

	public void run() {
		try {
			doConnect();// 连接
		} catch (IOException e) {
			e.printStackTrace();
		}
		while (!stop) {
			try {
				selector.select(1000);
				Set<SelectionKey> selectionKeys = selector.selectedKeys();
				Iterator<SelectionKey> it = selectionKeys.iterator();
				SelectionKey key = null;
				while (it.hasNext()) {
					key = it.next();
					it.remove();
					handleInput(key);
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		if (selector != null) {
			try {
				selector.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	private void handleInput(SelectionKey key) throws IOException {
		//这个通道已经可以读取了
		if (key.isValid()) {
			SocketChannel sc = (SocketChannel) key.channel();
			if (key.isConnectable()) {
				if (sc.finishConnect()) {
				} else {
					System.exit(1);
				}
			}
			if (key.isReadable()) {// 读取消息
				ByteBuffer readBuffer = ByteBuffer.allocate(1024);
				int read = sc.read(readBuffer);
				if (read > 0) {
					readBuffer.flip();
					byte[] bytes = new byte[readBuffer.remaining()];
					readBuffer.get(bytes);
					String body = new String(bytes, "utf-8");
					System.out.println("现在时间为：" + body);
					this.stop = true;
				} else if (read < 0) {
					key.cancel();
					sc.close();
				} else {
				}
			}

		}
	}

	private void doConnect() throws IOException {
		if (socketChannel.connect(new InetSocketAddress(host, port))) {
			socketChannel.register(selector, SelectionKey.OP_READ);
		} else {
			socketChannel.register(selector, SelectionKey.OP_CONNECT);
		}

	}

	private void doWrite(SocketChannel socketChannel,String request)throws IOException {
		byte[] bytes = request.getBytes();
		ByteBuffer writeBuff = ByteBuffer.allocate(bytes.length);
		writeBuff.put(bytes);
		writeBuff.flip();
		socketChannel.write(writeBuff);
		if (!writeBuff.hasRemaining()) {
			System.out.println("客户端发送命令成功");
		}
	}
	

	public void sendMsg(String msg) throws Exception{  

        doWrite(socketChannel, msg);  
	
    }  


}

服务端

Server类.


public class Server {

	private static int DEFAULT_PORT = 8081;
	private static ServerHandler serverHandler;

	public static void start() {
		start(DEFAULT_PORT);
	}

	public static synchronized void start(int port) {

		if (serverHandler != null) {
			serverHandler.stop();
		}
		
		serverHandler = new ServerHandler(port);
		new Thread(serverHandler, "Server").start();
	}

	/**
	 * 1.创建channel,监听连接
	 * 2.创建多路复用器Selector,将Channel注册到Selector中
	 * 3.Selector去轮询所有注册在其上的channel,当发现一个或多个就绪时,返回就绪的监听事件
	 * 4.程序匹配到监听事件,进行处理
	 * @param args
	 */
	public static void main(String[] args) {

		// 运行服务器
		Server.start();

	}

}

ServerHandler类.

public class ServerHandler implements Runnable {

    private Selector selector = null;
    private ServerSocketChannel serverChannel = null;
    private boolean stop;

	/**
	 * 初始化多路复用器，绑定监听端口
	 *
	 * @param port
	 */
    public ServerHandler(int port) {
        try {
            selector = Selector.open();
            serverChannel = ServerSocketChannel.open();
            serverChannel.configureBlocking(false);
            serverChannel.socket().bind(new InetSocketAddress(port), 1024);
            serverChannel.register(selector, SelectionKey.OP_ACCEPT);
            System.out.println("服务器监听" + port);
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(1);
        }


    }

    public void stop() {
        this.stop = true;
    }

    public void run() {
        while (!stop) {
            try {
                selector.select(1000);
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> it = selectionKeys.iterator();
                SelectionKey key = null;
                while (it.hasNext()) {
                    key = it.next();
                    it.remove();
                    try {
                        handleInput(key);
                    } catch (IOException e) {
                        if (key != null) {
                            key.cancel();
                            if (key.channel() != null)
                                key.channel().close();
                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
        if (selector != null) {
            try {
                selector.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
	
    /**
     * 处理事件
     * @param key
     * @throws IOException
     */
    private void handleInput(SelectionKey key) throws IOException {
        if (key.isValid()) {
            if (key.isAcceptable()) {
                ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
                SocketChannel sc = ssc.accept();
                sc.configureBlocking(false);
                sc.register(selector, SelectionKey.OP_READ);
            }
            if (key.isReadable()) {
                SocketChannel sc = (SocketChannel) key.channel();
                ByteBuffer readBuff = ByteBuffer.allocate(1024);
                //非阻塞的
                int read = sc.read(readBuff);
                if (read > 0) {
                    readBuff.flip();
                    byte[] bytes = new byte[readBuff.remaining()];
                    readBuff.get(bytes);
                    String body = new String(bytes, "utf-8");
                    System.out.println("服务收到消息：" + body);
                    String currentTime = new Date(System.currentTimeMillis()).toString();
                    doWrite(sc, currentTime);
                } else if (read < 0) {
                    key.cancel();
                    sc.close();
                } else {
                }
            }
        }
    }

    /**
     * 异步发送应答消息 
     * @param sc
     * @param content
     * @throws IOException
     */
    private void doWrite(SocketChannel sc, String content) throws IOException {
        if (content != null && content.trim().length() > 0) {
            byte[] bytes = content.getBytes();
            ByteBuffer byteBuffer = ByteBuffer.allocate(bytes.length);
            byteBuffer.put(bytes);
            byteBuffer.flip();
            sc.write(byteBuffer);
        }
    }
}

运行结果

在这里插入图片描述
在这里插入图片描述

今天的分享就到这里了,有问题可以在评论区留言,均会及时回复呀.
我是bling,未来不会太差,只要我们不要太懒就行, 咱们下期见.
在这里插入图片描述

程序员bling
关注
  • 4
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
Java Socket实现单线程通信的方法示例
08-30
主要介绍了Java Socket实现单线程通信的方法,结合具体实例形式分析了java socket单线程通信的原理与客户端、服务器端相关实现技巧,需要的朋友可以参考下
Java NIO Socket基本
03-28
NULL 博文链接：https://b-l-east.iteye.com/blog/1254693
Java中的网络编程：从Socket到NIO
最新发布
微赚淘客开发者博客
07-30 635
今天我们来探讨Java中的网络编程，从基础的Socket编程到更高级的NIO（New Input/Output）编程。本文介绍了Java中的网络编程，从基础的Socket编程到高级的NIO编程。对于小规模、低并发的应用，可以使用简单的Socket编程。对于高并发、大数据量的应用，建议使用NIO。NIO由于采用了非阻塞IO和基于通道的模型，可以更好地支持高并发的网络应用，尤其适合大型服务器应用。NIO的编程模型比传统IO复杂，需要处理通道、选择器和缓冲区，但它提供了更高的灵活性和性能。语句可以简化资源管理。
Java Socket 之 NIO
Spontaneous_0的博客
01-12 374
Java Socket 之 NIO
Java网络编程：Socket与NIO的高级应用
weixin_53840353的博客
05-22 796
在现代软件开发中，网络通信是不可或缺的一部分。Java提供了强大的网络编程支持，包括传统的Socket API和更高级的NIO（New Input/Output）库。本文将详细介绍如何使用Java Socket进行网络通信，并深入探讨NIO的高级特性，如通道、缓冲区和选择器。
Java中的Socket你了解吗
个人博客，欢迎收藏。https://xiaoaozz.github.io/
01-15 1520
Java中的普通Socket和NioSocket的简单介绍和使用。
java nio 实现socket
09-27
java nio 实现socketjava nio 实现socketjava nio 实现socketjava nio 实现socketjava nio 实现socket
java之socket编程（NIO）
我想月薪过万的博客
08-20 735
效果展示 原理分析 NIO: 非阻塞型 IO 自从 jdk 1.4 之后，增加了 nio 库，支持非阻塞型 IO 操作 代码展示 package NIO; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.ServerSocketChannel; import java.nio.channels.SocketChannel; import java.util.Arr
Java Socket实战 使用NIO包实现Socket通信
smithdoudou88的专栏
08-05 686
Java Socket实战 使用NIO包实现Socket通信 前面几篇文章介绍了使用java.io和java.net类库实现的Socket通信，下面介绍一下使用java.nio类库实现的Socket。 java.nio包是Java在1.4之后增加的，用来提高I/O操作的效率。在nio包中主要包括以下几个类或接口: * Buffer：缓冲区，用来临时存放输入或输出数据。 * Char
Java NIO socket编程实例 （转）
11-28 168
Java代码   晚上学习了下Java 的 NIO Socket编程，写了下面这个小程序，包括服务器端与客户端。实现的功能为客户端向服务器端发送随即数目的消息，服务器端一条一条的回应。消息内容保存在talks.properties文件中，内容为：      Hi=Hi   Bye=Bye   床前明月光=疑是地上霜   举头望明月=低头思故乡   少小离家老大回=乡...
基于Java NIO的Socket通信
热门推荐
千与的专栏
03-20 2万+
Java NIO模式的Socket通信，是一种同步非阻塞IO设计模式，它为Reactor模式实现提供了基础。 下面看看，Java实现的一个服务端和客户端通信的例子。 NIO模式的基本原理描述如下： 服务端打开一个通道（ServerSocketChannel），并向通道中注册一个选择器（Selector），这个选择器是与一些感兴趣的操作的标识（SelectionKey，即通过这个标识可以定位到
java Socket通信实现
06-06
Java Socket通信实现是Java网络编程中的重要组成部分，它允许两台计算机通过TCP/IP协议进行双向通信。在Java中，Socket提供了低级别的、基于连接的、面向数据流的通信API，可以用于实现客户端-服务器架构的应用程序...
nio.rar_Java socketA_java nio_java socket a
09-24
标题中的“Java socketA_java nio_java socket a”可能是指使用Java NIO实现的Socket通信，这里的"A"可能是表示"Advanced"或"Alternative"，意味着比传统的阻塞I/O模型更为高级或替代方案。 在Java Socket API中，...
java nio socket_Java Nio（三） - 用NIO实现高性能socketserver
weixin_31874603的博客
02-24 535
socket server是基于TCP协议的C/S通信模式下，服务器端的实现。一个socket server最主要的工作是处理网络IO，同事，高效处理网络IO也是一个socket server最重要的性能指标。本文会用java NIO框架实现一个同步非阻塞的socket server。最基础的结构首先从最基础的考虑。一个socket server最简单最经典的实现必然是多线程阻塞的版本：主线程监听...
Java网络编程：Socket与NIO技术详解
光剑书架上的书
01-28 1399
1.背景介绍 1. 背景介绍 Java网络编程是一门重要的技能，它涉及到通信、数据传输、并发等多个领域。在Java中，Socket和NIO是两种常用的网络编程技术，它们各自具有不同的优势和应用场景。本文将详细介绍Socket与NIO技术的核心概念、算法原理、最佳实践以及实际应用场景。 2. 核心概念与联系 2.1 Socket概述 Socket是一种用于建立客户端和服务端之间通信的技术，...
java NIO Socket 总结
此鸟不鸣
05-20 252
对于服务器 socketChannel （ServerSocketChannel），唯一（也只能）关心的操作是 OP_ACCEPT（表示一个新的客户端连接）。 一般一个线程应可以共享一个 Buffer 。 在没有客户端请求时，Selector.select() 将一直堵塞。应该将此做为唯一的堵塞时刻（在 I/0 Socket 中，在读数据时也会堵塞），做为服务器一般会无限循环此条件。 在自 ...
Java NIO Socket 非阻塞通信
weixin_30675247的博客
10-17 258
相对于非阻塞通信的复杂性，通常客户端并不需要使用非阻塞通信以提高性能，故这里只有服务端使用非阻塞通信方式实现 客户端： package com.test.client; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.n...
java socket nio_Java Socket NIO详解(转)
weixin_28759829的博客
02-12 545
java选择器(Selector)是用来干嘛的？2009-01-12 22:21jsptdut | 分类：JAVA相关 | 浏览8901次如题，不要贴api的，上面的写的我看不懂希望大家能给我个通熟易懂的例子还有ServerSocketChannel这个类，java.nio这个包里的东西，我看api也不懂～哎，恼火呀又是你呵～ssc.register( selector, SelectionKey...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员bling

义父,感谢支持

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值