Java学习笔记13-BIO阻塞、NIO非阻塞网络编程

最新推荐文章于 2021-11-19 17:53:24 发布
最新推荐文章于 2021-11-19 17:53:24 发布
阅读量340 收藏 1
点赞数
分类专栏： Java # 网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jwx90312/article/details/103167481
版权

Java学习笔记13-BIO阻塞、NIO非阻塞网络编程

BIO阻塞式

BIO 就是传统的 java.io 包，它是基于流模型实现的，交互的方式是阻塞方式，也就是说在读入输入流或者输出流时，在读写动作完成之前，线程会一直阻塞在那里，它们之间的调用是可靠的线性顺序。它的优点就是代码比较简单、直观；缺点就是 IO 的效率和扩展性很低，容易成为应用性能瓶颈。

阻塞（blocking）IO：资源不可用时，IO请求一直阻塞，直到返回结果（有数据或超时）。

非阻塞（non-blocking）IO：资源不可用时，IO请求离开返回，返回数据标识资源不可用。

同步（synchronous）IO：应用阻塞在发送或接收数据的状态，直到数据成功传输或返回失败。

异步（asynchronous）IO：应用发送或接收数据后立即返回，实际处理是异步执行的。

阻塞和非阻塞是获取资源的方式，同步和异步是程序如何处理资源的逻辑设计。

代码中使用的API：ServerSocket#accept、InputStream#read（我们这里用的BufferedReader#readLine）都是阻塞的API。操作系统底层API中，默认Socket操作都是Blocking型，send / recv等接口都是阻塞的。带来的问题：阻塞导致在处理网络I/O时，一个线程只能处理一个网络连接。

下面我们直接上代码感受下BIO服务端与客户端的网络通信~

BIO服务端测试代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @Author: Wenx
 * @Description:
 * @Date: Created in 2019/11/18 21:02
 * @Modified By：
 */
public class BIOServer {
    public static void main(String[] args) throws IOException {
        ExecutorService executorService = Executors.newCachedThreadPool();

        // 服务端在20480端口监听客户端请求的TCP连接
        ServerSocket server = new ServerSocket(20480);
        System.out.println("Socket服务端-启动");
        while (!server.isClosed()) {
            // 等待客户端的连接，如果没有获取连接则阻塞
            Socket client = server.accept();
            System.out.println("接收到客户端连接：" + client);
            // 为每个客户端连接开启一个线程
            executorService.execute(() -> {
                try {
                    // 获取Socket的输入流，用来接收从客户端发送过来的数据
                    BufferedReader buf = new BufferedReader(new InputStreamReader(client.getInputStream(), "UTF-8"));
                    // 获取Socket的输出流，用来向客户端发送数据
                    PrintStream out = new PrintStream(client.getOutputStream(), false, "UTF-8");
                    String msg;
                    // 接收从客户端发送过来的数据
                    while ((msg = buf.readLine()) != null) {
                        if (msg.length() == 0) {
                            out.println("");
                            break;

                            // 响应结果 200
                            //OutputStream outputStream = client.getOutputStream();
                            //outputStream.write("HTTP/1.1 200 OK\r\n".getBytes());
                            //outputStream.write("Content-Length: 11\r\n\r\n".getBytes());
                            //outputStream.write("Hello World".getBytes());
                            //outputStream.flush();
                        }
                        System.out.println(msg);
                        // 将接收到的字符串前面加上“已收到”，发送到对应的客户端
                        out.println("已收到：" + msg);
                    }
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    try {
                        System.out.println("客户端连接关闭：" + client);
                        client.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        server.close();
        System.out.println("Socket服务端-关闭");
    }
}

BIO客户端测试代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.net.SocketTimeoutException;

/**
 * @Author: Wenx
 * @Description:
 * @Date: Created in 2019/11/18 21:31
 * @Modified By：
 */
public class BIOClient {
    public static void main(String[] args) throws IOException {
        // 客户端请求与本机在20480端口建立TCP连接
        Socket client = new Socket("127.0.0.1", 20480);
        client.setSoTimeout(600000);
        System.out.println("Socket客户端-启动");
        // 获取Socket的输入流，用来接收从服务端发送过来的数据
        BufferedReader buf = new BufferedReader(new InputStreamReader(client.getInputStream(), "UTF-8"));
        // 获取Socket的输出流，用来发送数据到服务端
        PrintStream out = new PrintStream(client.getOutputStream(), false, "UTF-8");
        // 获取键盘输入
        BufferedReader input = new BufferedReader(new InputStreamReader(System.in, "UTF-8"));

        new Thread(() -> {
            String msg;
            // 接收从键盘发送过来的数据
            try {
                System.out.print("请输入信息：");
                while ((msg = input.readLine()) != null) {
                    out.println(msg);
                    if (msg.length() == 0) {
                        break;
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();

        try {
            String echo;
            // 从服务器端接收数据有个时间限制（系统自设，也可以自己设置），超过了这个时间，便会抛出该异常
            while ((echo = buf.readLine()) != null) {
                if (echo.length() == 0) {
                    System.out.println("服务端连接关闭");
                    break;
                }
                System.out.println(echo);
                System.out.print("请输入信息：");
            }
        } catch (SocketTimeoutException e) {
            System.out.println("Time out, No response");
        }

        input.close();
        if (client != null) {
            // 如果构造函数建立起了连接，则关闭套接字，如果没有建立起连接，自然不用关闭
            client.close(); // 只关闭socket，其关联的输入输出流也会被关闭
            System.out.println("Socket客户端-关闭");
        }
    }
}
Http协议

Http协议-请求数据包解析

第一部分：请求行，请求类型，资源路径以及HTTP版本。

第二部分：请求头部，紧接着请求行（即第一行）之后的部分，用来说明服务器要使用的附加信息。

第三部分：空行，请求头部后面的空行是必须的，请求头部和数据主体之间必须有换行。

第四部分：请求数据也叫主体，可以添加任意的数据。这个例子的请求数据为空。

GET / HTTP/1.1
Host: localhost:20010
Connection: keep-alive
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9
Cookie: __guid=111872281.1396970361135427000.1571659920085.445

Http协议-响应数据包解析

第一部分：状态行，HTTP版本、状态码、状态消息。

第二部分：响应报头部，紧接着请求行（即第一行）之后的部分，用来说明服务器要使用的附加信息。

第三部分：空行，请求头部后面的空行是必须的，请求头部和数据主体之间必须有换行。

第四部分：响应正文，可以添加任意的数据。这个例子的响应正文为“Hello World”。

HTTP/1.1 200 OK
Content-Length: 11

Hello World

Http协议-响应状态码

1xx（临时响应）：表示临时响应并需要请求者继续执行操作的状态代码。

2xx（成功）：表示成功处理了请求的状态代码。

3xx（重定向）：表示要完成请求，需要进一步操作。通常，这些状态代码用来重定向。

4xx（请求错误）：这些状态代码表示请求可能出错，妨碍了服务器的处理。

5xx（服务器错误）：这些状态代码表示服务器在尝试处理请求时发生内部错误。这些错误可能是服务器本身的错误，而不是请求出错。

NIO非阻塞式

NIO 是 Java 1.4 引入的 java.nio 包，提供了新的 Java IO操作非阻塞API。用意是替代 Java IO 和 Java Networking相关的API，NIO中有三个核心组件：Buffer（缓冲区）、Channel（通道）、Selector（选择器），可以构建多路复用的、同步非阻塞 IO 程序，同时提供了更接近操作系统底层高性能的数据操作方式。

Buffer缓冲区

缓冲区本质上是一个可以写入数据的内存块（类似数组），然后可以再次读取。此内存块包含在NIO Buffer对象中，该对象提供了一组方法，可以轻松地使用内存块。相比较直接的对数组的操作，Buffer API更加容易操作和管理。

使用Buffer进行数据写入与读取，需要进行如下四个步骤：

  1. 将数据写入缓冲区
  2. 调用buffer.flip()，转换为读取模式
  3. 缓冲区读取数据
  4. 调用buffer.clear()或buffer.compact()清除缓冲区

Buffer工作原理

Buffer三个重要属性：

capacity容量：作为一个内存块，Buffer具有一定的固定大小，也称为“容量”。

position位置：写入模式时代表写数据的位置。读取模式时代表读数据的位置。

limit限制：写入模式，限制等于buffer的容量。读取模式下，limit等于写入的数据量。

写入模式长度为8读取模式长度为8
位置0（有数据）position -->位置0（有数据）
位置1（有数据）位置1（有数据）
位置2（有数据）位置2（有数据）
position -->位置3（有数据）limit -->位置3（有数据）
位置4位置4
位置5位置5
位置6位置6
limit / capacity -->位置7capacity -->位置7

Buffer测试代码

import java.nio.ByteBuffer;

/**
 * @Author: Wenx
 * @Description:
 * @Date: Created in 2019/11/19 11:33
 * @Modified By：
 */
public class BufferDemo {
    public static void main(String[] args) {
        // 构建一个byte字节缓冲区，容量是4
        ByteBuffer byteBuffer = ByteBuffer.allocate(4);
        //ByteBuffer byteBuffer = ByteBuffer.allocateDirect(4); // 堆外
        // 默认写入模式，查看三个重要的指标
        System.out.println(String.format("初始化：position位置：%s, limit限制：%s capacity容量：%s,", byteBuffer.position(), byteBuffer.limit(), byteBuffer.capacity()));
        // 写入3字节的数据
        byteBuffer.put((byte) 1);
        byteBuffer.put((byte) 2);
        byteBuffer.put((byte) 3);
        // 再看数据
        System.out.println(String.format("写入3字节后，position位置：%s, limit限制：%s capacity容量：%s,", byteBuffer.position(), byteBuffer.limit(), byteBuffer.capacity()));

        // 转换为读取模式(不调用flip方法，也是可以读取数据的，但是position记录读取的位置不对)
        byteBuffer.flip();
        System.out.println(String.format("转换为读取模式后，position位置：%s, limit限制：%s capacity容量：%s,", byteBuffer.position(), byteBuffer.limit(), byteBuffer.capacity()));
        // 读取2字节的数据
        byte a = byteBuffer.get();
        System.out.println(a);
        byte b = byteBuffer.get();
        System.out.println(b);
        System.out.println(String.format("读取2字节数据后，position位置：%s, limit限制：%s capacity容量：%s,", byteBuffer.position(), byteBuffer.limit(), byteBuffer.capacity()));

        // 继续写入3字节，此时读模式下，limit=3，position=2.继续写入只能覆盖写入一条数据
        // clear()方法清除整个缓冲区。compact()方法仅清除已阅读的数据。转为写入模式
        byteBuffer.compact(); // buffer : 1 , 3
        System.out.println(String.format("清除已阅读的数据后，position位置：%s, limit限制：%s capacity容量：%s,", byteBuffer.position(), byteBuffer.limit(), byteBuffer.capacity()));
        // 写入3字节的数据
        byteBuffer.put((byte) 3);
        byteBuffer.put((byte) 4);
        byteBuffer.put((byte) 5);
        System.out.println(String.format("再写入3字节后最终的情况，position位置：%s, limit限制：%s capacity容量：%s,", byteBuffer.position(), byteBuffer.limit(), byteBuffer.capacity()));

        // rewind() 重置position为0
        // mark() 标记position的位置
        // reset() 重置position为上次mark()标记的位置
    }
}

ByteBuffer内存类型

ByteBuffer为性能关键性代码提供了直接内存（direct堆外）和非直接内存（heap堆）两种实现。

堆外内存获取的方式：ByteBuffer directByteBuffer = ByteBuffer.allocateDirect(noByteBuffer);

好处：

  1. 进行网络IO或者文件IO时比HeapByteBuffer少一次拷贝。（file/socket — OS memory — jvm heap）CG会移动对象内存，在写file或socket的过程中，JVM的实现中，会先把数据复制到堆外，再进行写入。
  2. GC范围之外，降低GC压力，但实现了自动管理。DirectByteBuffer中有一个Cleaner对象（PhantomReference），Cleaner被GC前会执行clean方法，触发DirectByteBuffer中定义的Deallocator。

建议：

  1. 性能确实可观的时候才去使用；分配给大型、长寿命；（网络传输、文件读写场景）
  2. 通过虚拟机参数MaxDirectMemorySize现值大小，防止耗尽整个机器的内存。
Channel通道

BIO：代码 --byte[]数据写入–> outputStream -----网络-----> inputStream --read阻塞读取–> 代码

NIO：代码 --> Buffer --缓冲区数据写入通道–> channel -----网络-----> channel --通道数据写入缓冲区–> Buffer–> 代码

Channel的API涵盖了 TCP/UDP 网络和文件IO：FileChannel、DatagramChannel、SocketChannel、ServerSocketChannel，和标准IO Stream操作的区别：在一个通道内进行读取和写入，而stream通常是单向的（input或output），可以非阻塞读取和写入通道，通道始终读取和写入缓冲区。

Selector选择器

Selector是一个Java NIO组件，可以检查一个或多个NIO通道，并确定哪些通道已准备好进行读取或写入。实现多个线程可以管理多个通道，从而管理多个网络连接。

一个线程使用Selector监听多个channel的不同事件：四个事件分别对应SelectionKey四个常量。

  1. Connect连接（SelectionKey.OP_CONNECT）
  2. Accept准备就绪（SelectionKey.OP_ACCEPT）
  3. Read读取（SelectionKey.OP_READ）
  4. Write写入（SelectionKey.OP_WRITE）

实现一个线程处理多个通道的核心概念理解：事件驱动机制。

非阻塞的网络通道下，开发者通过Selector注册对于通道感兴趣的事件类型，线程通过监听事件来出发相应的代码执行。（拓展：更底层是操作系统的多路复用机制）

NIO对比BIO

BIO：客户端 -----连接-----> Acceptor ----------> 线程-n read…write

  • 阻塞IO，线程等待时间长
  • 一个线程负责一个连接处理
  • 线程多且利用率低

NIO：客户端 -----连接-----> Selector事件通知机制 ----------> 线程-n read…write

  • 非阻塞IO，线程利用率更高
  • 一个线程处理多个连接事件
  • 性能更强大

如果你的程序需要支撑大量的连接，使用NIO是最好的方式。

Tomcat8中，已经完全去除BIO相关的网络处理代码，默认采用NIO进行网络处理。

NIO与多线程结合的改进方案

采用Reactor模式进行改进，参照Doug Lea的著名文章《Scalable IO in Java》

NIO服务端测试代码

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.util.Iterator;
import java.util.Set;

/**
 * @Author: Wenx
 * @Description:
 * @Date: Created in 2019/11/19 13:26
 * @Modified By：
 */
public class NIOServer {
    public static void main(String[] args) throws IOException {
        // 1. 创建Socket服务端
        ServerSocketChannel server = ServerSocketChannel.open();
        server.configureBlocking(false); // 设置为非阻塞模式
        // 2. 构建一个Selector选择器，并且将ServerSocketChannel的accept事件注册绑定到selector选择器上
        Selector selector = Selector.open();
        server.register(selector, SelectionKey.OP_ACCEPT);
        // 3. 绑定端口
        server.socket().bind(new InetSocketAddress(20480)); // 绑定端口
        System.out.println("Socket服务端-启动");

        ByteBuffer readBuff = ByteBuffer.allocate(1024);
        ByteBuffer writeBuff;

        while (true) {
            // 不再轮询通道，改用下面轮询事件的方式。select方法有阻塞效果，直到有事件通知才会有返回
            selector.select();
            // 获取事件
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            // 遍历查询结果e
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            while (iterator.hasNext()) {
                // 被封装的查询结果
                SelectionKey key = iterator.next();
                // 关注 Accept 和 Read 两个事件
                if (key.isAcceptable()) {
                    ServerSocketChannel channel = (ServerSocketChannel) key.channel();
                    // 拿到客户端的连接通道，并且将SocketChannel的read事件注册绑定到selector选择器上
                    SocketChannel client = channel.accept(); // mainReactor 轮询accept
                    client.configureBlocking(false);
                    client.register(selector, SelectionKey.OP_READ);
                    System.out.println("接收到客户端连接：" + client.getRemoteAddress());
                } else if (key.isReadable()) {
                    SocketChannel client = (SocketChannel) key.channel();
                    try {
                        readBuff.clear();
                        while (client.isOpen() && client.read(readBuff) != -1) {
                            // 长连接情况下，需要手动判断数据有没有读取结束
                            // 此处做一个简单的判断：超过0字节就认为请求结束了
                            if (readBuff.position() > 0) break;
                        }
                        // 如果没数据了, 则不继续后面的处理
                        if (readBuff.position() == 0) continue;

                        readBuff.flip();
                        byte[] content = new byte[readBuff.limit()];
                        readBuff.get(content);
                        System.out.println("已收到：" + new String(content));
                        System.out.println("来自：" + client.getRemoteAddress());

                        // TODO 业务操作 数据库 接口调用等等

                        // 响应结果 200
                        String response = "HTTP/1.1 200 OK\r\n" +
                                "Content-Length: 11\r\n\r\n" +
                                "Hello World";
                        writeBuff = ByteBuffer.wrap(response.getBytes());
                        while (writeBuff.hasRemaining()) {
                            client.write(writeBuff);
                        }

                    } catch (IOException e) {
                        // e.printStackTrace();
                        key.cancel(); // 取消事件订阅
                    }
                }
                iterator.remove();
            }
            selector.selectNow();
        }
        //channel.close();
        //System.out.println("Socket服务端-关闭");
    }
}

NIO客户端测试代码

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

/**
 * @Author: Wenx
 * @Description:
 * @Date: Created in 2019/11/19 13:26
 * @Modified By：
 */
public class NIOClient {
    public static void main(String[] args) throws IOException {
        // 客户端请求与本机在20480端口建立TCP连接
        SocketChannel client = SocketChannel.open();
        client.configureBlocking(false); // 设置为非阻塞模式
        client.connect(new InetSocketAddress("127.0.0.1", 20480));
        while (!client.finishConnect()) {
            // 没连接上，则一直等待
            Thread.yield();
        }
        System.out.println("Socket客户端-启动");

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入：");
        // 发送内容
        String msg = scanner.nextLine();
        ByteBuffer writeBuff = ByteBuffer.wrap(msg.getBytes());
        while (writeBuff.hasRemaining()) {
            client.write(writeBuff);
        }

        // 读取响应
        System.out.println("收到服务端响应：");
        ByteBuffer readBuff = ByteBuffer.allocate(1024);
        while (client.isOpen() && client.read(readBuff) != -1) {
            // 长连接情况下，需要手动判断数据有没有读取结束
            // 此处做一个简单的判断：超过0字节就认为请求结束了
            if (readBuff.position() > 0) break;
        }

        readBuff.flip();
        byte[] content = new byte[readBuff.limit()];
        readBuff.get(content);
        System.out.println("发送数据：" + new String(content));

        scanner.close();
        client.close();
    }
}

小结

NIO为开发者提供了功能丰富及强大的IO处理API，但是在应用于网络应用开发的过程中，直接使用 JDK提供的API，比较繁琐。而且想要将性能进行提升，光有NIO还不够，还需要将多线程技术与之结合起来。

因为网络编程本身的复杂性，以及 JDK API开发的使用难度较高，所以在开源社区中，涌出来很多对 JDK NIO进行封装、增强后的网络编程框架，例如：Netty、Mina等。

Wenx408
关注
专栏目录
阿里架构师整理的 Netty 学习笔记之：Java NIO 网络编程
m0_72011831的博客
06-18 197
本系列为 Netty 学习笔记，本篇介绍总结Java NIO 网络编程。Netty 作为一个异步的、事件驱动的网络应用程序框架，也是基于NIO的客户、服务器端的编程框架。其对 Java NIO 底层 API 进行了封装，因此有必要对 Java 网络编程做个大概了解。本篇将重点放在 NIO 网络编程模型上，对 BIO 及 AIO 仅做简要说明；...
尚硅谷Netty系列学习笔记一《BIO、NIO、AIO简单介绍》
qq_38965140的博客
02-06 424
前言：1.由于工作需要，需要学习下Netty框架，随对学习进行整理。方便后期的翻阅。大家也可以借鉴下。 2.学习基于尚硅谷的Netty视频教程，笔记也会查阅其他资料来完善观看视频中本人理解模糊的地方。 了解Netty之前需要熟悉 同步、异步、阻塞、非阻塞都是什么意思。 同步： A调用B，需要A主动等待B处理完后返回结果！ 例如：去书店，问老板 有没有xxx书，老板说等一下啊，我去找一下。你必须等待老板找完后给你返回结果！ 异步： A调用B，A无需主动等待B的返回结...
同步阻塞式I/O（BIO）示例
juzhenxing的博客
08-22 191
特点 缺乏弹性伸缩的能力，无法满足高性能、高并发接入的场景 客户端个数与服务端线程数：1:1 阻塞io，同步io api使用简单 调试简单 可靠性差 吞吐量低 服务器端 package com.example.demo.bio; import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; /** * 同步阻塞io */ public class TimeServer { public
java基础：网络编程（二）TCP网络编程
lalala_dxf的博客
11-19 819
网络编程（二）TCP网络编程 1、概述 在TCP通信协议下，能实现两台计算机之间的数据交互，并且它们要严格区分客户端（Client）与服务端（Server） 客户端和服务端通信的步骤： （1）服务端先进行启动，并占用一个指定的端口号，等待客户端的连接。 （2）客户端主动发起服务端的连接，在连接成功之后，就可以进行数据发送。 服务端不能主动连接客户端，必须由客户端先行发起连接才行 在java中，对于这样基于TCP协议下连接通信的客户端和服务端，分别进行了抽象： java.net.Socket类表示客户端
java tcp 线程_【Java TCP/IP Socket】基于线程池的TCP服务器（含代码）
weixin_31951319的博客
02-12 168
了解线程池在http://blog.csdn.net/ns_code/article/details/14105457(读书笔记一：TCP Socket)这篇博文中，服务器端采用的实现方式是：一个客户端对应一个线程。但是，每个新线程都会消耗系统资源：创建一个线程会占用CPU周期，而且每个线程都会建立自己的数据结构(如，栈)，也要消耗系统内存，另外，当一个线程阻塞时，JVM将保存其状态，选择另外一个...
java tcp server例子_java 通过socket实现TCP编程的例子
weixin_39627699的博客
02-13 644
1.服务端ServerThread类/*** 该类为多线程类，用于服务端*/public class ServerThread implements Runnable {private Socket client = null;public ServerThread(Socket client) {this.client = client;}public void run() {try {//获取...
Java Socket
weixin_30340617的博客
04-07 57
一、网络基础 　　TCP/IP协议：是以TCP和IP为接触的不同层次上多个协议的集合。 　　TCP：传输控制协议 IP：网际协议 　　IP地址：为实现网络中不通过计算机之间的通信，每台计算机必须有一个唯一的标识。 　　端口：用于区分不同的应用程序，端口号范围为0~65535，其中0~1023位系统所保留。 　　IP地址和端口号组成了所谓的Socket，Socket是网络上个运行的程序之...
Java网络编程深度解析：BIO、NIO与AIO学习笔记
资源摘要信息:"《一站式学习Java网络编程——全面理解BIO、NIO、AIO》是一本专注于Java网络编程技术的书籍。本书的标题明确指出了其主要内容和学习目标，即通过一个全面的学习过程来理解Java中的三种I/O模型：阻塞IO...
"Java网络编程一站式学习:全面理解BIO:NIO:AIO1
在这门课程中，学员将深入理解BIO（同步阻塞IO）、NIO（同步非阻塞IO）和AIO（异步非阻塞IO）这三个重要的网络编程模型。通过实践项目和综合项目的练习，学员将能够熟练运用这些网络编程技术。 本章第一部分介绍了...
深入浅出Java网络编程：掌握BIO、NIO与AIO
读书笔记中的内容涵盖了Java网络编程的核心知识点，包括BIO、NIO和AIO的原理及应用场景，以及如何在Java中实现这些模型的编程细节。通过学习，读者可以深入理解Java网络编程的内在机制，掌握高效处理网络数据的技术...
java iso8583 socket 服务_Java版：一个极致精简的socket通讯服务器和客户端
weixin_39932300的博客
11-29 311
什么是socket网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket。建立网络通信连接至少要一对端口号(socket)。socket本质是编程接口(API)，对TCP/IP的封装，TCP/IP也要提供可供程序员做网络开发所用的接口，这就是Socket编程接口；HTTP是轿车，提供了封装或者显示数据的具体形式；Socket是发动机，提供了网络通信的能力。TCP/...
InputStream read（）方法详解
热门推荐
u010276761的博客
09-28 9万+
在Java7中，InputStream被定义为一个抽象类，相应的，该类下的read()方法也是一个抽象方法，这也就意味着必须有一个类继承InputStream并且实现这个read方法。 查阅Java7 API，我们可以看到，在InputStream中定义了三个重载的read()方法： 但是在这三个方法中，只有参数列表为空的read方法定义为抽象方法，这也就意味着在直接继承自InputStre
Panabit解决网络打印机多打印一页GET / HTTP/1.1的问题
奇怪的老司机
03-31 7608
故障表现：网络打印机打印完文档后会多打印一页GET/HTTP/1.1登录到Panabit上，执行下面命令即可解决，但不知道这条命令是的作用是什么。floweye dpi config xping_enable=0本文链接地址: Panabit解决网络打印机多打印一页GET / HTTP/1.1的问题...
BufferedReader的readLine()为非阻塞
u012507301的博客
05-18 3097
BufferedReader的readLine()为非阻塞，阻塞部分主要在 Socket clientSocket = serverSocket.accept(); public class ShutDownServer { static ServerSocket serverSocket = null;// 服务socket public stat
常见的IO模型
peterkang202的专栏
04-09 857
本文讨论的背景是Linux环境下的network IO。本文最重要的参考文献是Richard Stevens的“UNIX? Network Programming Volume 1, Third Edition: The Sockets Networking ”，6.2节“I/O Models ”，Stevens在这节中详细说明了各种IO的特点和区别，如果英文够好的话，推荐直接阅读。Stevens的
FileInputStream和read函数的使用
王铮Nio的博客
05-28 1723
    初学java，菜鸟笔记。    如何使用FileInputStream类读取文件中的数据。import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; public class testtt3 { public static void main(Stri...
深入java SocketInputStream看read具体如何操作
星空的专栏
10-24 2万+
在网络编程中，常用的操作莫过于读写了，最重要的，也是最经常让程序员犯迷糊的地方。想要具体理解，当然还是看源码，看下面代码： ServerSocket serverSocket = new ServerSocket(4887); Socket client= serverSocket.accept(); InputStream is= client.getInputStream
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值