Java NIO网络编程

最新推荐文章于 2022-08-08 10:59:45 发布
最新推荐文章于 2022-08-08 10:59:45 发布
阅读量198 收藏
点赞数
分类专栏： NIO 文章标签： nio 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wsdfym/article/details/103569541
版权

BIO

BIO：传统的网络通讯模型，同步阻塞IO。服务端创建一个ServerSocket， 客户端用Socket去连接服务端的ServerSocket， ServerSocket接收到了一个的连接请求就会创建一个Socket和一个线程去跟那个Socket进行通讯。接着客户端和服务端就进行阻塞式的通信：
阻塞式具体体现在：
①服务端等待连接请求
②创建一个线程跟客户端进行和通信阻塞等待客户端发送的数据。
③客户端阻塞等待服务器端处理后返回响应，在响应返回前，客户端那边就阻塞等待，什么事都做不了。
缺点：
①每次一个客户端接入，都需要创建一个线程来服务这个客户端。当客户端过多时，就会造成服务端的线程数量可能达到了几千几万，这样就可能会造成服务端过载过高，最后宕机
②阻塞时什么事都做不了，只能阻塞等待，浪费资源。

服务器代码会在A行代码中阻塞，一直等待客户端连接。一旦有客户端连接就能得到一个Socket连接，接着就会继续往下阻塞等待客户端的输入信息（一下代码在正式使用时会增加线程池，当有连接时，从线程池获得一个线程执行操作）
服务端代码样例

public class TCPServer {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket sc = null;
        try {
             serverSocket = new ServerSocket(9999);
        } catch (IOException e) {
            e.printStackTrace();
        }
        while (true){
            try {
                sc = serverSocket.accept(); //A
                String ip = sc.getInetAddress().getHostAddress();
                System.out.println(ip+"已连接");
                InputStream is = sc.getInputStream();//B
                byte[] b = new byte[1024];
                is.read(b);
                System.out.println(ip+":"+new String(b));
                OutputStream outputStream = sc.getOutputStream();
                outputStream.write("知道了".getBytes());
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                try {
                    sc.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

客户端代码样例
C行代码会一直阻塞直到服务器端做出响应

public class TCPClient {
    public static void main(String[] args) {
        while (true){
            try {
                Socket s = new Socket("127.0.0.1",9999);
                OutputStream outputStream = s.getOutputStream();
                System.out.println("请输入");
                Scanner scanner = new Scanner(System.in);
                String msg = scanner.nextLine();
                outputStream.write(msg.getBytes());
                InputStream inputStream = s.getInputStream();//C
                byte[] b = new byte[1024];
                inputStream.read(b);
                System.out.println("服务器:"+new String(b));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

NIO

核心组件

  • 通道（Channel）
    首先说一下Channel，“通道/连接”。Stream是单向的，譬如：InputStream, OutputStream是单向的而Channel是双向的，既可以用来进行读操作，又可以用来进行写操作。网络NIO中的Channel也是双向的，可以从另一端获得数据也可以向另一端写入数据。
    1）FileChannel（文件IO）
    2）DatagramChannel（UDP）
    3）SocketChannel（ClientTCP）
    4）ServerSocketChannel（ClientTCP）
  • 缓冲区（Buffer）
    NIO中的关键Buffer实现有
    ByteBuffer
    CharBuffer
    DoubleBuffer
    FloatBuffer
    IntBuffer
    LongBuffer,
    ShortBuffer
  • 选择器（Selectors）
    Selectors(选择器)能够检测一到多个NIO通道，并能够知道连接是否做好准备的组件。一个单独的线程就可以管理多个channel，从而管理多个网络连接。要使用Selector, 得向Selector注册Channel。轮询一个或多个NIO Channel的状态是否有事件发生。有相应事件发生则执行相应逻辑。这样既可实现了利用一个线程无管理多数连接。不用再一个客户端一个连接。避免了多个线程的切换与维护。在这里插入图片描述
  • selectionKey：代表socket与Select之间发生的事件关系。
    OP_ACCEPT:有新的网络连接可以建立（accept），值为16
    OP_CONNECT:连接已经建立,值为8
    OP_READ/OP_WRITE 读写操作 值为1，4

服务端代码样例

public class ChatServer {
    private ServerSocketChannel serverSocketChannel;
    private Selector selector;
    private static final int PORT = 9999;

    public ChatServer() {
        try {
            //得到ServerSocketChannel
            serverSocketChannel = ServerSocketChannel.open();
            //得到selector
            selector = Selector.open();
            //绑定端口号
            serverSocketChannel.bind(new InetSocketAddress(PORT));
            //设置非阻塞方式
            serverSocketChannel.configureBlocking(false);
            //设置selector给ServerSocketChannel
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            System.out.println("server reday");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void start() throws IOException {
        //准备执行任务
        while (true) {
            //每四秒监控一下客户端，返回值为就绪的channel连接数量
            if (selector.select(4000) == 0) {
                //非阻塞式，可以执行其他的事务
                System.out.println("没有准备就绪的连接，或已注册的连接");
                continue;
            }
            //有连接就绪了，得到selectionKey判断事件
            //得到所有的发生事件
            Iterator<SelectionKey> selectionKeyIterable = selector.selectedKeys().iterator();
            while (selectionKeyIterable.hasNext()) {
                SelectionKey selectionKey = selectionKeyIterable.next();

                if (selectionKey.isAcceptable()) {
                    System.out.println("isAcceptable");
                    SocketChannel socketChannel = null;

                    //客户端连接事件
                    socketChannel = serverSocketChannel.accept();
                    //设置非阻塞方式
                    socketChannel.configureBlocking(false);
                    //将该通道注册到监控器中，注重监听读事件
                    socketChannel.register(selector, SelectionKey.OP_READ);
                    System.out.println(socketChannel.getRemoteAddress());
                } else if (selectionKey.isReadable()) {
                    readMsg(selectionKey);
                }
                selectionKeyIterable.remove();
            }
        }
    }

    /**
     * 收到消息，并且广播
     *
     * @param selectionKey
     */
    private void readMsg(SelectionKey selectionKey) throws IOException {
        //获得通道
        Channel channel = selectionKey.channel();
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

        int count = ((SocketChannel) channel).read(byteBuffer);
        if (count > 0) {
            String msg = new String(byteBuffer.array());
            System.out.println(msg);
            //发送广播
            broadCast(msg, channel);
        }
    }

    /**
     * 给所有的连接发送消息
     *
     * @param msg
     * @param expect
     */
    private void broadCast(String msg, Channel expect) throws IOException {
        for (SelectionKey key : selector.keys()) {
            Channel channel = key.channel();
            if (channel instanceof SocketChannel && channel != expect) {
                ByteBuffer byteBuffer = ByteBuffer.wrap(msg.getBytes());
                ((SocketChannel) channel).write(byteBuffer);
            }
        }
    }

    public static void main(String[] args) {
        ChatServer chatServer = new ChatServer();
        try {
            chatServer.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端样例代码

public class ChatClient {
    private String userName;
    private final static String HOST="127.0.0.1";
    private int port=9999;
    private SocketChannel socketChannel;

    public ChatClient() {

        try {
            //得到一个网络连接
            socketChannel = SocketChannel.open();
            //设置阻塞方式
            socketChannel.configureBlocking(false);
            //封装连接地址
            InetSocketAddress address = new InetSocketAddress(HOST,port);
            //使连接连上客户端
            if (!socketChannel.connect(address)){
                //连接失败
                while (!socketChannel.finishConnect()){
                    //未连接上，持续连接，在连接过程中非阻塞
                    System.out.println("正在连接服务器....");
                }
            }
            userName = socketChannel.getLocalAddress().toString();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void sendMsg(String msg) throws IOException {
        if (msg.equals("bye")){
            socketChannel.close();
            return;
        }
        ByteBuffer byteBuffer = ByteBuffer.wrap((userName+":"+msg).getBytes());
        socketChannel.write(byteBuffer);
    }

    public void receiveMsg() throws IOException {
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        int count = socketChannel.read(byteBuffer);
        if (count > 0) {
            String msg = new String(byteBuffer.array());
            System.out.println(msg.trim());
        }
    }

    public static void main(String[] args) {
        ChatClient chatClient = new ChatClient();

        new Thread(){
            @Override
            public void run() {
                while (true){
                    try {
                        chatClient.receiveMsg();
                        Thread.sleep(2000);
                    } catch (IOException e) {
                        e.printStackTrace();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();

        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String msg = scanner.nextLine();
            try {
                chatClient.sendMsg(msg);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
吴顺达
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java NIO网络编程
weixin_44817973的博客
03-29 732
NIO介绍 NIO即no-blocking IO，表示同步非阻塞IO操作。采用多路复用器，事件驱动机制，当发生io请求时，触发相应的事件，多路复用器中的轮询器即selector轮询到事件，从而交由线程执行。请求发起方发起请求之后并不会被堵塞，可以设置为非堵塞的状态。 三大核心组件 java nio框架中，有三大核心的组件：Buffer、Channel、Selector。其关系图为： Buffer buffer即数据缓冲区，用于存储发送或读取Channel中的数据。数据流向是双向的，读写模式的切换需要依赖f
Java中的NIO编程
weixin_42105432的博客
07-19 378
1 BIO和NIO简介 BIO、NIO、AIO简介 1）Java BIO ： 同步并阻塞(传统阻塞型)，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销 2）Java NIO ： 同步非阻塞，服务器实现模式为一个线程处理多个请求(连接)，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求就进行处理 3）Java AIO(NIO.2) ： 异步非阻塞，AIO 引入异步通道的概念，采用了 Pr
Mina网络应用程序NIO框架实战详解
04-24
网络编程的基本模型是C/S模型，即两个进程间的通信。课程通过循序渐进的方式从相关的名词概率介绍，到基础的模型BIO、NIO、AIO实现和练习，重点讲解NIO相关的知识，然后延伸到NIO框架上去练习。课程还将在工作中应用较多的几种编解码器进行详细分析和练习。Mina是基于java NIO类库开发；采用非阻塞方式的异步传输；事件驱动；支持批量数据传输；支持TCP、UDP协议；支持Spring；采用优雅的松耦合架构；可灵活的加载过滤器机制；
java NIO网络编程之SelectionKey
qq_40837310的博客
12-16 517
概述 SelectionKey是java.nio.channels包下的一个类，主要用于绑定selector和chanel之间的关联（注册关系）。 SelectionKey定义了selector监控事件的四种类型： public static final int OP_READ = 1 << 0; //1，数据读取完成触发的事件 public static final int OP_WRITE = 1 << 2; //4 数据写入完成触发的事件 public static f
JAVA中NIO的网络编程
qq_46288317的博客
03-18 326
1 Selector选择器老大 Selector 选择器，网络编程使用NIO的大哥！！！ 服务器可以执行一个线程，运行Selector程序，进行监听操作。 新连接， 已经连接， 读取数据，写入数据 Selector常用方法： public static Selector Open(); 得到一个选择器对象 public int select(long timeout); 监听所有注册通道，...
Java中NIO以及在网络编程中的应用
cosmos_lee
05-09 2433
https://blog.csdn.net/u012156116/article/details/80051912之前在上面的博客中简单的介绍了JavaIO和JavaNIO的相关知识，今天想把5月1号之前看的Java网络编程以及NIO在其中的应用一起介绍下。参考：http://www.importnew.com/19816.htmlhttp://www.importnew.com/22623.ht...
Java NIO 网络编程初探
12-22
Java NIO 网络编程初探 1. Java NIO Java 1.4 版本添加了一个新的IO API，称为NIO（New IO）。NIO拥有所有IO的功能，但是操作方法却完全不一样。NIO支持面向缓冲区的、基于通道的IO操作。能够更加高效的进行IO操作。...
java网络编程NIO视频教程
最新发布
09-12
01-Java NIO-课程简介.mp4 02-Java NIO-概述.mp4 03-Java NIO-Channel-概述.mp4 04-Java NIO-Channel-FileChannel(介绍和示例).mp4 05-Java NIO-Channel-FileChannel详解(一).mp4 06-Java NIO-Channel-FileChannel...
java nio 网络编程指南
05-20
基于java nio的服务器与客户端的开发指南
java网络编程
03-11
java网络编程包括socket tcp/udp io/nio讲解 http协议 jdbc rmi java的安全框架等知识
Java中NIO详解
qq_40276626的博客
09-04 1841
NIO是当前Java中最流行的IO方式，大名鼎鼎的网络框架Netty就是基于NIO的。本文将仔细介绍NIO的工作方式。 NIO简介 NIO的底层原理就是对IO进行多路复用，对IO多路复用不太了解的可以看我之前写的文章Linux中网络IO模型详解 通过多路复用可以在一个线程中监听多个连接，节省了线程资源。 NIO详解 NIO中有三个核心： 1、Buffer简介 Buffer就是缓冲池。Buffer和Channel配合使用。 1、将Channel中的数据读取到Buffer中。 2、将Buffer中的数据写入到C
Java服务端（二）- Java网络编程NIO
qq_40191710的博客
06-01 214
Java Nio 基础知识点 并发：多线程抢占CPU，可能不同时执行，侧重于多个任务交替执行。（一个CPU） 并行：线程可以不共享CPU，可每个线程一个CPU同时执行多个任务。（多个CPU） 阻塞：相对于数据而言，需要一直等待数据准备好才能进行下一步操作（BIO，accept） 非阻塞：不管数据有没有准备好都可以往下执行下一步逻辑 同步：相对于IO操作而言，在...
Java NIO学习（二）SelectionKey详解
热门推荐
lhxaiee123的博客
07-30 1万+
书接上文上一篇博客中的结尾讲到将Channel注册在某个Selector的管辖范围之下：channel.register(selector, SelectionKey.OP_ACCEPT);由这个register()方法的第二个参数SelectionKey.OP_ACCEPT，我们引出关于SelectionKey的讨论。常量OP_ACCEPT是SelectionKey中一个重要属性Interest
Java网络编程（9）NIO - 群聊系统
key_768的博客
03-07 646
目标 完成一个群聊系统： 服务器可接收多个客户端的连接并接收信息 服务器向除了发送消息的客户端的其他客户端发送消息 客户端可以发送消息和接收消息 完成 服务器 package com.company.GroupChat; import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuf...
Java原生网络编程之NIO
故不积跬步无以至千里
08-08 282
Socket是应用层与TCP/IP协议族通信中的中间软件抽象层，它是一组接口。TCP用主机的IP地址加上主机上的端口号作为TCP连接的端点，这种端点就叫做套接字(socket)；
NIO网络相关基础知识
weixin_33946605的博客
03-04 86
前面的文章NIO基础知识介绍了Java NIO的一些基本的类及功能说明，Java NIO是用来替换java 传统IO的，NIO的一些新的特性在网络交互方面会更加的明显。 Java 传统IO的弊端     “基于JVM来实现每个通道的轮询检查通道状态的方法是可行的，但仍然是有问题的，检查每个通道是否就绪是至少需要一次系统调用，执行的代价是非...
Java NIO：Selector详解以及在网络编程中的应用
保暖透气大裤衩LeoLee的博客
09-23 272
概述 Selector <---> Channel <---> Buffer，三者都支持双向的数据传递 在NIO网络编程中，Selector&Channel&Buffer三者的关系是十分紧密的，Buffer从Channel中读写，Channel注册在Selector中。在以往的网络编程中，通常都是通过创建一个线程来维护一个socket通讯，在业务量较小时，是可以很好的完成工作的，但是一旦客户端增多，创建的线程也随之增多，对硬件的开销是非常大的。这时候NIO的S
NIO学习之Selector，SelectionKey与客户端与服务端通信简单实现（1）
qq_34332010的博客
08-29 1407
选择器（Selector）的 作用：将通道感兴趣的事件放入队列中，而不是马上提交给应用程序，等已注册的通道自己来请求处理这些事件。换句话说，就是选择器将会随时报告已经准备好了的通道，而且是按照先进先出的顺序。 Selector类定义如下： open()方法，静态方法，用于获取1个Selector对象keys()方法，用于获取所有注册到Selector对象上的SelectionKeysel
java nio网络编程示例
07-11
以下是一个使用 Java NIO（New I/O）进行网络编程的简单示例： ```java import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值