NIO基础及进阶案例---NIO聊天室

最新推荐文章于 2023-01-30 23:21:29 发布

夏心07

最新推荐文章于 2023-01-30 23:21:29 发布

阅读量229

点赞数

本文链接：https://blog.csdn.net/weixin_40240756/article/details/107146129

版权

java 同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

nio

2 篇文章 0 订阅

订阅专栏

首先来简单说一下IO

IO

阻塞式数据传输

IO设计的核心思想：装饰者模式

装饰者模式

装饰模式是指在不影响原有对象的情况下，动态地、无侵入地给一个对象添加一些额外的功能。

InputStreamReader iReader = new InputStreamReader(new FileInputStreamReader(new File("D:\\abc.txt")));

可以通过装饰模式对各个功能进行模块化封装。

组成：

被装饰的对象：

抽象构建角色(Component)
具体构建角色(ConcreteComponent)

装饰者：

装饰角色(Decorator)
具体装饰角色(ConcreteDecorator)

示例：

抽象构件角色

public interface Phone { 
    public void call(); 
}

具体构件角色

public class BasePhone implements Phone { 
    @Override 
    public void call() { 
        System.out.println("打电话"); 
    } 
}

装饰角色

public abstract class SmartPhone implements Phone {
    /**
     * 包含一个对真实对象的引用
     */
    private Phone phone;

    public SmartPhone(Phone phone) {
        super();
        this.phone = phone;
    }

    @Override
    public void call() {
        phone.call();
    }
}

具体装饰角色AISmartPhone

public class AISmartPhone extends SmartPhone {

    public AISmartPhone(Phone phone) {
        super(phone);
    }

    /**
     * 给电话增加新的功能：人工智能
     */
    public void aiFunction() {
        System.out.println("电话拥有人工智能的强大功能");
    }

    @Override
    public void call() {
        super.call();
        aiFunction();
    }
}

具体装饰角色AutoSizeSmartPhone

public class AutoSizeSmartPhone extends SmartPhone {
    public AutoSizeSmartPhone(Phone phone) {
        super(phone);
    }

    /**
     * 给电话增加新的功能：手机尺寸自动伸缩
     */
    public void autoSize(){
        System.out.println("手机的尺寸可以自动伸缩");
    }
    @Override
    public void call(){
        super.call();
        autoSize();
    }
}

IO远程传输文件

示例使用IO和new Thead()

缺点

数据以阻塞的方式传输
当服务端每次收到客户端发来的连接时，都会通过new Thread(new SendFile(socket)).start()创建一个线程，去处理这个客户端的连接。而每次jvm创建一个线程，大约会消耗1Mb内存，并且在创建、线程时cpu也会因为对线程的上小文切换而消耗性能。

NIO

new io | non blocking io

非阻塞式数据传输

非阻塞式
面向通道（Channel）和缓冲区（Buffer）
提供了选择器（Selector）

NIO数据存储结构：缓冲区Buffer

底层为数组，用于存储数据

7种类型缓冲区，用于存储不同类型的数据，都继承自Buffer（与java的8种基本类型相比，缺少了BooleanBuffer）

ByteBuffer、ShortBuffer、IntBuffer、LongBuffer、FloatBuffer、DoubleBuffer、CharBuffer

ByteBuffer

属性：

int position：下一个将要读或写的元素位置，也就是说position永远指向Buffer中最后一次操作元素的下一个位置
int limit：限制Buffer中能够存放的元素个数，limit及之后的位置不能使用。
int capacity：Buffer的最大容量，在创建后不能修改
int mark：标记，使用reset()方法返回到该标记的位置
long address：堆外内存的地址

前四个属性大小关系：

0<=mark<=position<=limit<=capacity

方法：

分配缓冲区

allocate(int capacity)

allocateDirect(int capacity)'

向缓冲区存放数据

put(byte)
put(int,byte)
put(byte[])
put(byte[],int,int)

从缓冲区中读取数据

get()
get(int)
get(byte[])
get(byte[] dst, int offset, int length) 注意，此方法可以直接从Buffer中的指定位置offset开始读取数据，而不需要flip()或rewind()

将一个Buffer转为一个只读Buffer

asReadOnlyBuffer()

将原Buffer从position到limit之间的部分数据交给一个新的Buffer引用。也就是说，此方法返回的Buffer所引用的数据，是原Buffer的一个子集。并且新的Buffer引用和原Buffer引用共享相同的数据。

slice()

ByteBuffer buffer = ByteBuffer.allocate(8);
//buffer：0,1,2,3,4,5,6,7
for (int i = 0; i < buffer.capacity(); i++) {
    buffer.put((byte)i);
}
buffer.position(2);
buffer.limit(6);
//sliceBuffer：2,3,4,5；获取从position到limit之间buffer的引用。
ByteBuffer sliceBuffer = buffer.slice();
//sliceBuffer与原Buffer共享相同的数据；即修改sliceBuffer中的数据时，buffer也会改变。
for (int i = 0; i < sliceBuffer.capacity(); i++) {
    byte b = sliceBuffer.get(i);
    b += 100 ;
    sliceBuffer.put(i,b);
}
//测试
System.out.println("当修改了sliceBuffer之后，查看buffer：");
buffer.position(0) ;
buffer.limit(buffer.capacity());
while (buffer.hasRemaining()) {
    //{x,x,x,x,x,x}  buffer.hasRemaining()：判断是否有剩余元素
    System.out.print( buffer.get() +",");
}

返回一个内容为array的Buffer。此外，如果修改缓冲区的内容，array也会随着改变，反之亦然。

wrap(byte[])

父类Buffer中4个常用方法

1.flip()

public final Buffer flip() {
    limit = position;
    position = 0;
    mark = -1;
    return this;
}

2.rewind()

public final Buffer rewind() {
    position = 0;
    mark = -1; //取消mark
    return this;
}

3.clear()

public final Buffer clear() {
    position = 0;
    limit = capacity;
    mark = -1;
    return this;
}

4.mark()/reset()

public final Buffer mark() {
    mark = position;
    return this;
}
public final Buffer reset() {
    int m = mark;
    if (m < 0)
        throw new InvalidMarkException();
    position = m;
    return this;
}

//使用
ByteBuffer buffer2 = ByteBuffer.allocate(100) ;
buffer2.put("abcdefg".getBytes()) ;

//在此时的position位置处，做一个标记mark
buffer2.mark() ;
System.out.println("position：" + buffer2.position());
System.out.println("mark：" + buffer2.mark().position());
/*
 通过get(byte[] dst, int offset, int length)方法，读取buffer中的“cde”。
 注意，此方法可以直接从Buffer中的指定位置offset开始读取数据，而不需要flip()或rewind()。
*/
buffer2.get(bs,2,3);//10 why？？看如下get的源码
buffer2.reset();//恢复到mark的位置 2
System.out.println("position：" + buffer2.position());
System.out.println("mark：" + buffer2.mark().position());

get(byte[] dst, int offset, int length)的源码

public ByteBuffer get(byte[] dst, int offset, int length) {
    checkBounds(offset, length, dst.length);
    if (length > remaining())
        throw new BufferUnderflowException();
    int end = offset + length;
    for (int i = offset; i < end; i++)
        dst[i] = get();
    return this;
}

其他方法

hasRemaining()
remaining()
array()
putDouble()、getDouble()等： ByteBuffer存储各类型数据，必须保证get和put顺序一致

ByteBuffer buffer = ByteBuffer.allocate(100);
buffer.putChar('a');
buffer.putInt(2);
buffer.putLong(50000L);
buffer.putShort((short) 2);
buffer.putDouble(12.4);
System.out.println(buffer.position());
buffer.flip();
System.out.println(buffer.getChar());
System.out.println(buffer.getInt());
System.out.println(buffer.getLong());
System.out.println(buffer.getShort());
System.out.println(buffer.getDouble());

缓冲区的搬运工：Channel

数据的双向传输，同一个通道既可以用于读数据，也可以用于写数据

缓冲区(货车)+通道(道路) 就是使用通道对缓冲区、文件或套接字进行数据传输

Channel接口

其实现类有FileChannel、SocketChannel、ServerSocketChannel、DatagramChannel等

获取Channel对象

FileInputStream、FileOutputStream、RandomAccessFile

FileChannel.getChannel()

Socket、ServerSocket、DatagramSocket

xxxChannel.getChannel()

FileChannel等各个Channel实现类

public static FileChannel open(Path path, OpenOption... options) throws IOException

Files

public static SeekableByteChannel newByteChannel(Path path, OpenOption... options)throws IOException

示例

文件复制

//使用非直接缓冲区复制文件
public static void test2_2() throws IOException {
    long start = System.currentTimeMillis();
    FileInputStream input = new FileInputStream("e:\\JDK_API.CHM");
    FileOutputStream out = new FileOutputStream("e:\\JDK_API_COPY.CHM");
    //获取通道
    FileChannel inChannel = input.getChannel();
    FileChannel outChannel = out.getChannel();
    ByteBuffer buffer = ByteBuffer.allocateDirect(1024);

    while (inChannel.read(buffer) != -1) {
        buffer.flip();
        outChannel.write(buffer);
        buffer.clear(); // 这步很重要 
    }
    outChannel.close();
    inChannel.close();
    out.close();
    input.close();
    long end = System.currentTimeMillis();
    System.out.println("复制操作消耗的时间（毫秒）：" + (end - start));
}

也可以使用非直接缓冲区allocateDirect()

public abstract class ByteBuffer  extends Buffer  implements Comparable<ByteBuffer> {
    // ... 
    public static ByteBuffer allocateDirect(int capacity) {
        return new DirectByteBuffer(capacity);
    }
    //...
}

DirectByteBuffer 表示堆外内存（直接缓冲区）

MappedByteBuffer 是堆外内存的父类可以使用MappedByteBuffer来操作堆外内存，MappedByteBuffer也称为内存映射文件

class DirectByteBuffer extends MappedByteBuffer implements DirectBuffer {
// Cached unsafe-access object
    protected static final Unsafe unsafe = Bits.unsafe();
    private long address;
    //...
    DirectByteBuffer(int cap) {                   // package-private
    
        super(-1, 0, cap, cap);
        boolean pa = VM.isDirectMemoryPageAligned();
        int ps = Bits.pageSize();
        long size = Math.max(1L, (long)cap + (pa ? ps : 0));
        Bits.reserveMemory(size, cap);
    
        long base = 0;
        try {
            base = unsafe.allocateMemory(size); // 分配堆外内存  返回给base 
        } catch (OutOfMemoryError x) {
            Bits.unreserveMemory(size, cap);
            throw x;
        }
        unsafe.setMemory(base, size, (byte) 0);
        if (pa && (base % ps != 0)) {
            // Round up to page boundary
            address = base + ps - (base & (ps - 1));
        } else {
            address = base; // base赋值给address
        }
        cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
        att = null;
    }
}

使用零拷贝实现高性能文件传输

缓冲区操作两种方式：

直接缓冲区
非直接缓冲区

4次copy、4次用户空间与内核空间的上下文切换

读操作

磁盘文件---->OS提供的内核地址空间的内存中（第一次复制，OS上下文切换到内核模式）

内核地址空间内存中的文件---->JVM提供的用户地址空间的内存中（第二次复制，OS上下文切换到用户模式）

写操作

用户地址空间JVM内存中的文件---->OS提供的内核地址空间中的内存（第一次复制，OS上下文切换到内核模式）

内核地址空间中内存的文件---->磁盘文件（第二次复制，写入操作完毕后，OS上下文最终切换到用户模式以后）

文件内容要在用户地址空间和内核地址空间的两个内存中来回复制

堆外内存脱离了JVM的管控，受操作系统完全控制

问题：

1.read或write，为什么不直接在JVM内存中操作，而必须在内存和堆外内存间进行一次copy？

GC会不定时释放无用的对象，并且压缩某些内存区域。如果某一时间正在JVM中复制一个文件（该文件可能存在于JVM的多个位置），但由于GC的压缩操作可能会引起该文件在JVM中的位置发生改变，进而导致程序出现异常。

2.能否减少copy操作？

可以。使用直接缓冲区，就可以在JVM中通过一个address变量指向OS中的一块内存（“物理映射文件”）。之后就可以直接通过JVM使用OS中的内存。

这样，数据的复制操作都是在内核空间里进行的，也就是“零拷贝”（用户空间与内核空间之间的复制次数为零）。

但是，在内核空间内仍然可以有另外两次复制操作

3.能否进一步减少内核空间内部的复制次数呢？

可以，但需要操作系统的支持，需在内核空间中增加一个表示“文件描述符”的缓冲区，用以记录文件的大小，以及文件在内存中的位置。有了“文件描述符”的支持，最理想的“零拷贝”过程如下：

1.将磁盘文件的内容复制到内核空间（一次文件数据的复制），并用文件描述符记录文件大小和文件在内核空间中的位置。

2.将文件描述符的内容复制到输出缓冲区中（没有复制文件内容本身，而只复制了文件描述符），然后直接根据文件描述符寻找到文件内容并输出到磁盘。

文件描述符和文件内容两者的协同工作，需要操作系统底层scatter-and-gather功能。

零拷贝既减少了数据的复制次数，又降低了cpu的负载压力

可以使用JAVA API的MappedByteBuffer类和FileChannel中的transferFrom()/transferTo()方法，进行文件的零拷贝。

code:

本例是在直接缓冲区通过“内存映射文件”进行了文件复制；

public static void test3() throws IOException {
    long start = System.currentTimeMillis();
    //用文件的输入通道
    FileChannel inChannel
            = FileChannel.open(Paths.get("e:\\JDK_API.CHM"), StandardOpenOption.READ);
    //用文件的输出通道
    FileChannel outChannel = FileChannel.open(Paths.get("e:\\JDK_API2.CHM"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE);
    //输入通道和输出通道之间的内存映射文件（内存映射文件处于堆外内存中）
    MappedByteBuffer inMappedBuf = inChannel.map(FileChannel.MapMode.READ_ONLY, 0, inChannel.size());
    MappedByteBuffer outMappedBuf = outChannel.map(FileChannel.MapMode.READ_WRITE, 0, inChannel.size());
    //直接对内存映射文件进行读写
    byte[] dst = new byte[inMappedBuf.limit()];
    inMappedBuf.get(dst);
    outMappedBuf.put(dst);
    inChannel.close();
    outChannel.close();
    long end = System.currentTimeMillis();
    System.out.println("复制操作消耗的时间（毫秒）：" + (end - start));
}

文件修改：

public static void test6() throws IOException {
    RandomAccessFile raf = new RandomAccessFile("D:\\abc.txt", "rw");
    FileChannel channel = raf.getChannel();
    // mappedByteBuffer代表了abc.txt在内存中的映射文件
    MappedByteBuffer mappedByteBuffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, raf.length());
    mappedByteBuffer.put(1, (byte) 'X');
    mappedByteBuffer.put(1, (byte) 'Y');
    raf.close();
}

直接缓冲区是驻留在JVM之外的区域，因此无法受java代码及GC的控制。此外，分配直接缓冲区时系统开销很大，因此建议将直接缓冲区分配给哪些持久的、经常重用的数据使用。

如果更进一步使用“零拷贝”方式在直接缓冲区进行复制，效率会进一步提升。

//在直接缓冲区中，将输入通道的数据直接转发给输出通道
public static void test4() throws IOException {
    long start = System.currentTimeMillis();
    FileChannel inChannel = FileChannel.open(Paths.get("e:\\JDK_API.CHM"), StandardOpenOption.READ);
    FileChannel outChannel = FileChannel.open(Paths.get("e:\\JDK_API.CHM3"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE);
    inChannel.transferTo(0, inChannel.size(), outChannel);
    /*
     也可以使用输出通道完成复制，即上条语句等价于以下写法：
     outChannel.transferFrom(inChannel, 0, inChannel.size());
    */
    inChannel.close();
    outChannel.close();
    long end = System.currentTimeMillis();
    System.out.println("复制操作消耗的时间（毫秒）：" + (end - start));
}

NIO文件传输

public class NIOSendFile {
    public static void client() throws IOException {
        FileChannel inFileChannel = FileChannel.open(Paths.get("e:\\JDK_API.CHM"), StandardOpenOption.READ);
        //创建与服务端建立连接的SocketChannel对象
        SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 8888));
        //分配指定大小的缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        long start = System.currentTimeMillis();
        //读取本地文件，并发送到服务端
        while (inFileChannel.read(buffer) != -1) {
            buffer.rewind();
            socketChannel.write(buffer);
            buffer.clear();
        }
        inFileChannel.close();
        if (socketChannel != null) {
            socketChannel.close();
        }
        long end = System.currentTimeMillis();
        System.out.println("客户端发送文件耗时：" + (end - start));
    }

    public static void server() throws IOException {
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        FileChannel outFileChannel = FileChannel.open(Paths.get("e:\\JDK_API4.CHM"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);
        //将服务绑定在8888端口上
        serverSocketChannel.bind(new InetSocketAddress(8888));//默认服务的ip就是 本机ip
        //创建与客户端建立连接的SocketChannel对象
        SocketChannel sChannel = serverSocketChannel.accept();
        System.out.println("连接成功...");

        long start = System.currentTimeMillis();
        //分配指定大小的缓冲区
        ByteBuffer buf = ByteBuffer.allocate(1024);
        //接收客户端发送的文件，并保存到本地
        while (sChannel.read(buf) != -1) {
            buf.flip();
            outFileChannel.write(buf);
            buf.clear();
        }
        System.out.println("接收成功！");

        sChannel.close();
        outFileChannel.close();
        serverSocketChannel.close();
        long end = System.currentTimeMillis();
        System.out.println("服务端接收文件耗时：" + (end - start));
    }

    public static void client2() throws IOException {
        long start = System.currentTimeMillis();
        SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 8888));

        FileChannel inFileChannel = FileChannel.open(Paths.get("e:\\JDK_API.CHM"), StandardOpenOption.READ);
        //通过inFileChannel.size()获取文件的大小，从而在内核地址空间中开辟与文件大小相同的直接缓冲区
        inFileChannel.transferTo(0, inFileChannel.size(), socketChannel);
        inFileChannel.close();
        if (socketChannel != null) {
            socketChannel.close();
        }
        long end = System.currentTimeMillis();
        System.out.println("客户端发送文件耗时：" + (end - start));
    }

    public static void main(String[] args) throws IOException {
//        server();
        client2();
    }
}

使用直接缓冲区客户端

未完待续。。。。。。。。。。。。。。。

夏心07

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
NIO基础及进阶案例---NIO聊天室

IO阻塞式数据传输IO设计的核心思想：装饰者模式装饰者模式装饰模式是指在不影响原有对象的情况下，动态地、无侵入地给一个对象添加一些额外的功能。InputStreamReader iReader = new InputStreamReader(new FileInputStreamReader(new File("D:\\abc.txt")));可以通过装饰模式对各个功能进行模块化封装。组成：被装饰的对象：抽象构建角色(Component) 具体构...
复制链接

扫一扫