NIO基础

最新推荐文章于 2024-05-22 16:45:32 发布
最新推荐文章于 2024-05-22 16:45:32 发布
阅读量340 收藏
点赞数
分类专栏： Java Socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hx1043116928/article/details/117662805
版权

non-blocking io 非阻塞IO

1.三大组件

1.1Channel&Buffer

Channel：双向通道，可读可写   Buffer：缓冲区

1.2 Selector

来1000个socket，要1000个线程服务。损耗太大。

阻塞模式的含义：thread处理socket1的时候就不能处理socket3(eg：服务器服务第一个客人点菜，买单的过程不能服务下一个客人)

所以适合短连接，早点处理完去服务下一个线程

selector版设计

selector监视这些channel要求，有人有处理需求就去处理

和线程池版的区别就是线程不会吊死在一个连接上，可以服务多个请求，线程利用率就提高了很多。

所以适合连接数多，但是流量低 的情况，一个channel流量多的话就不能让线程很好的服务其他的channel。

2.ByteBuffer

public class TestByteBuffer {
    @Test
    public void test(){
        //FileChannel
        //1.输入输出流 2.RandomAccessFile
        try(FileChannel channel = new FileInputStream("data").getChannel()){
            //读取需要一个缓冲区
            ByteBuffer buffer = ByteBuffer.allocate(10);
            while(true){
                //从channel读取数据，向buffer写入
                int len = channel.read(buffer);
                //Log.debug("读取到的字节数{}",len);
                if(len==-1){//没有内容了
                    break;
                }
                //打印buffer内容
                buffer.flip();//切换至读模式
                while(buffer.hasRemaining()){//是否还有剩余未读数据
                    byte b = buffer.get();
                    System.out.println((char) b);
                }
                buffer.clear();//切换为写模式

            }
        }catch (IOException ex){
            System.out.println(ex.toString());
        }
    }
}

2.2ByteBuffer结构

capacity：容量

position：索引  写入位置/读取位置

limit：写入/读取多少内容

调用flip会改两个指针的位置，position从写位置转到读的位置，limit从写的限制变为读的限制

compact：没读完但是现在要马上写，compact会把后面没读的移到起始位置，写只能从没读那些位置后面开始写。

package com.netty.demo;

import org.junit.jupiter.api.Test;

import java.nio.ByteBuffer;
import static com.netty.demo.ByteBufferUtil.debugAll;

public class TestBufferReadWrite {
    @Test
    public static void main(String[] args){
        ByteBuffer buffer = ByteBuffer.allocate(10);
        buffer.put((byte)0x61);//'a'
        debugAll(buffer);
    }
}

 

显示限制是10，现在可以从位置1开始写

如果不切换读模式，直接读，那么会直接读当前位置也就是position=1，读到的会是0

package com.netty.demo;

import org.junit.jupiter.api.Test;

import java.nio.ByteBuffer;
import static com.netty.demo.ByteBufferUtil.debugAll;

public class TestBufferReadWrite {
    @Test
    public static void main(String[] args){
        ByteBuffer buffer = ByteBuffer.allocate(10);
        buffer.put((byte)0x61);//'a'
        debugAll(buffer);
        System.out.println( buffer.get());
        buffer.flip();
        System.out.println(buffer.get());
    }
}

2.3ByteBuffer常见方法

put，get，clean，字符串与bytebuffer几种转换方法

2.4 Scattering Reads

分散读集中写

粘包半包分析

package com.netty.demo;

import org.junit.jupiter.api.Test;

import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.Random;

import static com.netty.demo.ByteBufferUtil.debugAll;

public class TestScatteringReads {
    private static void split(ByteBuffer source){
        source.flip();
        for(int i=0;i<source.limit();i++){
            if(source.get(i)=='\n'){
                int length = i+1-source.position();
                ByteBuffer target = ByteBuffer.allocate(length);
                //从source读，向target写
                for(int j=0;j<length;j++){
                    target.put(source.get());
                }
                debugAll(target);
            }
        }
        source.compact();//第一次未读的部分向前移动

    }
    @Test
    public static void main(String[] args){
        ByteBuffer source = ByteBuffer.allocate(32);
        source.put("hello,world\nI'm zhangsan\nHo".getBytes());
        split(source);
        source.put("w are you?\n".getBytes());
        split(source);
    }
}

3. 文件编程

3.1 FileChannel

FileChannel只能工作在阻塞模式下

data中文件写到to文件

package com.netty.demo;

import org.junit.jupiter.api.Test;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.channels.FileChannel;

public class TestFileChannelTransferTo {

    @Test
    public static void main(String[] args){
       try{
           FileChannel from = new FileInputStream("data").getChannel();
           FileChannel to = new FileOutputStream("to").getChannel();
           //效率高，底层会使用操作系统的零拷贝进行优化
           from.transferTo(0,from.size(),to);
       }catch (Exception ex){

       }
    }
}

3.2 传输数据大于2g时，

可以多次使用FileChannel进行传输，

package com.netty.demo;

import org.junit.jupiter.api.Test;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.channels.FileChannel;

public class TestFileChannelTransferTo {

    @Test
    public static void main(String[] args){
       try{
           FileChannel from = new FileInputStream("data").getChannel();
           FileChannel to = new FileOutputStream("to").getChannel();
           //效率高，底层会使用操作系统的零拷贝进行优化
           long size = from.size();
           //left表示每次传输完剩余的字节数量
           for(long left = size;left>0;){
               left-=from.transferTo(size-left,size,to);
           }
           from.transferTo(0,from.size(),to);
       }catch (Exception ex){

       }
    }
}

3.3 Path

3.4 Files

遍历文件目录

package com.netty.demo;

import org.junit.jupiter.api.Test;

import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.concurrent.atomic.AtomicInteger;

public class TestWakFileTree {
    @Test
    public static void main(String[] args) throws IOException {
        Path path = Paths.get("D:\\many tools\\JDK");
        // 文件目录数目
        AtomicInteger dirCount = new AtomicInteger();
        // 文件数目
        AtomicInteger fileCount = new AtomicInteger();
        Files.walkFileTree(path, new SimpleFileVisitor<Path>(){
            @Override
            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
                System.out.println("===>"+dir);
                // 增加文件目录数
                dirCount.incrementAndGet();
                return super.preVisitDirectory(dir, attrs);
            }

            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                System.out.println(file);
                // 增加文件数
                fileCount.incrementAndGet();
                return super.visitFile(file, attrs);
            }
        });
        // 打印数目
        System.out.println("文件目录数:"+dirCount.get());
        System.out.println("文件数:"+fileCount.get());
    }
}

4. 网络编程

package com.netty.demo;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.ArrayList;
import java.util.List;


import static com.netty.demo.ByteBufferUtil.debugRead;

public class Server {
    private static Logger logger = LoggerFactory.getLogger(Server.class);
    public static void main(String[] args) throws IOException {
        //使用nio来理解阻塞模式,单线程

        ByteBuffer buffer = ByteBuffer.allocate(16);
        //1.创建了服务器
        ServerSocketChannel ssc = ServerSocketChannel.open();

        //2.绑定监听端口
        ssc.bind(new InetSocketAddress(8080));

        //3.连接集合
        List<SocketChannel> channels = new ArrayList<>();

        while(true){
            //4.accept建立与客户端连接 SocketChannel用来与客户端通信
            logger.debug("connecting...");
            SocketChannel sc = ssc.accept();//accept是阻塞方法，会让线程暂停
            logger.debug("connection...{}",sc);
            channels.add(sc);
            for(SocketChannel channel:channels){
                //5.接受客户端发送的数据
                logger.debug("before read... {}",channel);
                channel.read(buffer);
                buffer.flip();
                debugRead(buffer);
                buffer.clear();
                logger.debug("after read...{}",channel);
            }
        }
    }
}

package com.netty.demo;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SocketChannel;

public class Client {
    public static void main(String[] args) throws IOException {
        SocketChannel sc = SocketChannel.open();
        sc.connect(new InetSocketAddress("localhost",8080));
        System.out.println("waiting...");
    }
}

处理消息的边界

服务器一次发送过多数据

服务端代码：

package com.netty.demo;

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.nio.charset.Charset;
import java.util.Iterator;

public class WriteServer {
    public static void main(String[] args) throws IOException {
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.configureBlocking(false);

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

        ssc.bind(new InetSocketAddress(8080));

        while(true){
            // 若没有事件就绪，线程会被阻塞，反之不会被阻塞。从而避免了CPU空转
            selector.select();
            Iterator<SelectionKey> iter = selector.selectedKeys().iterator();
            while (iter.hasNext()){
                SelectionKey key = iter.next();
                iter.remove();
                if(key.isAcceptable()){
                    SocketChannel sc = ssc.accept();
                    sc.configureBlocking(false);
                    //1.向客户端发送大量数据
                    StringBuilder sb = new StringBuilder();
                    for(int i=0;i<30000000;i++){
                        sb.append("a");
                    }
                    ByteBuffer buffer = Charset.defaultCharset().encode(sb.toString());

                    while (buffer.hasRemaining()){
                        //2.返回值代表实际写入的字节数
                        int write = sc.write(buffer);
                        System.out.println(write);
                    }

                }
            }

        }
    }
}

客户端代码：

package com.netty.demo;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class WriteClient {
    public static void main(String[] args) throws IOException{
        SocketChannel sc = SocketChannel.open();
        sc.connect(new InetSocketAddress("localhost",8080));
        //3.接收数据
        int count=0;
        while (true){
            ByteBuffer buffer = ByteBuffer.allocate(1024*1024);
            count+=sc.read(buffer);
            System.out.println(count);
            buffer.clear();
        }
    }
}

客户端分多次接收，但是服务端需要一直轮询，查询缓冲区是不是满的，还能不能继续写进数据

下面用可写事件来处理，避免轮询

package com.netty.demo;

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.nio.charset.Charset;
import java.util.Iterator;

public class WriteServer {
    public static void main(String[] args) throws IOException {
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.configureBlocking(false);

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

        ssc.bind(new InetSocketAddress(8080));

        while(true){
            // 若没有事件就绪，线程会被阻塞，反之不会被阻塞。从而避免了CPU空转
            selector.select();
            Iterator<SelectionKey> iter = selector.selectedKeys().iterator();
            while (iter.hasNext()){
                SelectionKey key = iter.next();
                iter.remove();
                if(key.isAcceptable()){
                    SocketChannel sc = ssc.accept();
                    sc.configureBlocking(false);
                    SelectionKey scKey = sc.register(selector,0,null);

                    //1.向客户端发送大量数据
                    StringBuilder sb = new StringBuilder();
                    for(int i=0;i<30000000;i++){
                        sb.append("a");
                    }
                    ByteBuffer buffer = Charset.defaultCharset().encode(sb.toString());
                    //2.返回值代表实际写入的字节数
                    int write = sc.write(buffer);
                    System.out.println(write);
                    //3.判断是否有剩余内容
                    if (buffer.hasRemaining()){
                        //4.关注可写事件
                        //scKey可能原来关注了其他事件，比如读事件
                        //不想覆盖掉他，就+scKey.interestOps()
                        scKey.interestOps(scKey.interestOps()+SelectionKey.OP_WRITE);
                        //5.把未写完的数据挂在scKey上
                        scKey.attach(buffer);
                    }
                }else if(key.isWritable()){
                    ByteBuffer buffer = (ByteBuffer) key.attachment();
                    SocketChannel sc = (SocketChannel) key.channel();
                    int write = sc.write(buffer);
                    System.out.println(write);
                    //6.清理一下，写完了buffer一直挂着，消耗大
                    if(!buffer.hasRemaining()){
                        key.attach(null);
                        key.interestOps(key.interestOps()-SelectionKey.OP_WRITE);
                    }
                }
            }

        }
    }
}

小结：

Thexin.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java nio基础使用示例
09-04
以上就是Java NIO的基础使用示例。通过这种方式，服务器可以高效地处理来自多个客户端的连接请求，而不需要为每个客户端创建单独的线程，降低了系统的资源消耗。值得注意的是，Java NIO的API相对复杂，使用时需要...
Java NIO基础视频教程、MINA视频教程、Netty快速入门视频 [有源码]-附件资源
03-05
Java NIO基础视频教程、MINA视频教程、Netty快速入门视频 [有源码]-附件资源
Java NIO传输文件
weixin_30399797的博客
12-01 471
首先请确保已经学习了Java NIO的基础知识，包括Buffer，Channel文件通道和Socket通道，Selector。关于NIO比起I/O的好处，区别等这里就不说了。具体可以参考后面的参考链接等。 这篇博客主要以一个使用NIO传输文件的例子来学习NIO中网络的基本操作 传统的监控socket方式存在的问题 传统的监控多个socket的Java解决方案是为每个socket创...
（一）socket·磨刀不误砍柴工 之 Java IO
༺ bestcxx的专栏 ༻
01-29 239
文章目录前言IOJava IO字节和字符字节流的两个抽象类字节输入流字节输出流字符流的两个抽象类字符输入流字符输出流字符-Java 包含哪些种类的字符字符流和字节流相互转化字节流通向字符流的桥梁字符流通向字节流的桥梁Java 中的换行符BufferedReader.readLine() 和 PrintWriter.println()的妙用BufferedReader.readLine()Print...
学习socket nio 之ByteBuffer
貌似君子的专栏
11-04 7610
1:什么是ByteBuffer？ ByteBuffer就是字节缓冲区.那什么是字节缓冲区？举个例子：就好比CPU和硬盘之间的内存。明白了吧。 2：ByteBuffer是用来干嘛呢？ 顾名思义，它是用来存放字节的。很常用的地方就是程序向网络中传送数据的时候。 3：怎么使用ByteBuffer？ 要使用ByteBuffer，理解其中3个指针式很重要的。position、limit和capac
ByteBuffer的allocate和allocateDirect
weixin_33726313的博客
09-21 838
在Java中当我们要对数据进行更底层的操作时，一般是操作数据的字节（byte）形式，这时经常会用到ByteBuffer这样一个类。ByteBuffer提供了两种静态实例方式：  Java代码   public static ByteBuffer allocate(int capacity)   public static ByteBuffer alloca...
Java NIO 学习笔记 - ByteBuffer （早期笔记）
热门推荐
Studying & Summarizing
02-14 1万+
（参考 “ibm nio入门”）在 NIO 库中，所有数据都是用缓冲区处理的。在读取数据时，它是直接读到缓冲区中的。在写入数据时，它是写入到缓冲区中的。任何时候访问 NIO 中的数据，都是将它放到缓冲区中。缓冲区实质上是一个数组。通常它是一个字节数组，但是也可以使用其他种类的数组。但是一个缓冲区不仅仅是一个数组。缓冲区提供了对数据的结构化访问，而且还可以跟踪系统的读/写进程。buffer其
Java NIO 基础
最新发布
wenqi1992的博客
05-22 1081
Java NIO 基础
【IT十八掌徐培成】Java基础第26天-04.NIO基础.zip
08-07
在这个课程中，IT十八掌徐培成老师将深入讲解Java NIO的基础知识。 NIO的核心组件主要包括通道（Channel）、缓冲区（Buffer）和选择器（Selector）。首先，通道是数据传输的路径，它可以读写数据，比如文件通道、...
NIO网络框架 xSocket
05-14
不过，使用任何框架都需要权衡，xSocket虽然提供了很多便利，但学习曲线可能较陡峭，需要开发者具备一定的Java NIO基础。总的来说，对于追求高性能、高并发的网络应用，xSocket是一个值得考虑的解决方案。
泛谈Java NIO
08-26
Java NIO 基础知识点总结 Java NIO（Non-Blocking I/O），全称 Java New I/O，是 Java 1.4 及以上版本中提供的一种新型 I/O 操作方式。相比传统的阻塞式 I/O，NIO 能提供非阻塞式的高伸缩性网络。 缓冲区（Buffer...
java_nio.rar_java nio
09-21
一、Java NIO基础 1. **通道(Channel)**：在NIO中，数据读写是通过通道完成的。通道类似于流，但不同的是，通道可以同时进行读写，并且可以保持打开状态以便后续操作。常见的通道类有FileChannel、SocketChannel、...
ByteBuffer使用实例
翁志艺的博客
10-25 231
[code="java"] package com.vyloy.server; import java.io.IOException; import java.nio.ByteBuffer; import java.nio.channels.Channels; import java.nio.channels.ReadableByteChannel; import java.nio...
底层实现和优化——深入思考Java IO和NIO（一）
weixin_51393513的博客
12-28 269
我之前经常这么问自己，我真的懂JAVA IO和NIO吗？看着很简单，也经常使用，可是用过就忘了。 JAVA IO是指Java程序处理输入输出，现在通常是指文件和网络IO。NIO是JDK 1.4之后提供的新的IO方面的API。 Java IO和NIO虽然看起来很简单，但要说点什么出来，却似乎有什么如鲠在喉，无从说起。 本文从底层源码、理论图解和模型思考几个方面尝试讲透JAVA IO和NIO。 Java IO JDK 1.4之前提供了Java io包。 Java IO API的设计特点 在java
bytebuffer的内存使用记录
程序员里的小女生
10-16 475
最近开发过程中需要使用到bytebuffer这个类。一开始是这样创建的。 ByteBuffer buffer = ByteBuffer.allocate(50 * 1024 * 1024) 本地测试没有问题，部署到测试环境，并发的时候出现问题了，报错说java no heap space。 查看源码，原来在初始化的时候，会先申请50MB的堆内存。所以多个同时申请，超过内存的话，则...
NIO项目源码.zip
06-24
1. NIO基础概念 - Channel（通道）：NIO的核心组件，它代表了数据传输的路径，如文件、套接字等。通道是双向的，可以同时进行读写操作。 - Buffer（缓冲区）：在NIO中，数据总是先被写入Buffer，然后从Buffer读取...
Java NIO基础与异步IO详解
1. **NIO基础知识**: - NIO的核心概念包括Buffer（缓冲区）、Channel（通道）和Selector（选择器）。Buffer是数据的临时存储区域，可以存储原始数据，并支持高效的数据读取和写入。Channel是数据传输的抽象通道，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值