NIO高级编程与Netty入门概述

最新推荐文章于 2023-06-04 19:22:54 发布
最新推荐文章于 2023-06-04 19:22:54 发布
阅读量105 收藏
点赞数
分类专栏： NIO与Netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/s_zero/article/details/104735948
版权

1. NIO同步阻塞与同步非阻塞

1.1 BIO与NIO

IO(BIO)和NIO区别:其本质就是阻塞和非阻塞的区别
阻塞概念:应用程序在获取网络数据的时候,如果网络传输数据很慢，就会一直等待,直到传输完毕为止。

非阻塞概念:应用程序直接可以获取已经准备就绪好的数据,无需等待。
IO为同步阻塞形式,NIO为同步非阻塞形式,NIO并没有实现异步,在JDK1.7后升级NIO库包，支持异步非阻塞

BIO：同步阻塞式IO，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。

NIO：同步非阻塞式IO，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。

AIO(其实就是升级的NIO2.0，仅jdk7以上支持)：异步非阻塞式IO，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。

同步时，应用程序会直接参与IO读写操作,并且我们的应用程序会直接阻塞到某一个方法上,直到数据准备就绪，或者采用轮训的策略实时检查数据的就绪状态,如果就绪则获取数据.

异步时,则所有的IO读写操作交给操作系统,与我们的应用程序没有直接关系，我们程序不需要关系IO读写，当操作系统完成了IO读写操作时,会给我们应用程序发送通知,我们的应用程序直接拿走数据极即可。

注：阻塞IO只与网络相关，本地没有阻塞IO概念。

1.2 伪异步

由于BIO一个客户端需要一个线程去处理，因此我们进行优化，后端使用线程池来处理多个客户端的请求接入，形成客户端个数M：线程池最大的线程数N的比例关系，其中M可以远远大于N，通过线程池可以灵活的调配线程资源，设置线程的最大值，防止由于海量并发接入导致线程耗尽。
原理：
当有新的客户端接入时，将客户端的Socket封装成一个Task（该Task任务实现了java的Runnable接口）投递到后端的线程池中进行处理，由于线程池可以设置消息队列的大小以及线程池的最大值，因此，它的资源占用是可控的，无论多少个客户端的并发访问，都不会导致资源的耗尽或宕机。

在下面1.3中的代码实际上都是伪异步，服务端接受请求过程中仍须等待。

1.3 使用多线程支持多个请求

服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善


/**
 * @Auther: 洺润Star
 * @Date: 2020/3/8 14:52
 * @Description:使用多线程改善tcp服务器&伪异步
 */
class TcpServerThread {
    public static void main(String[] args) throws IOException {
        System.out.println("tcp协议：服务端启动");
        ServerSocket serverSocket = new ServerSocket(8080);

        try {
            while (true){
                //通过多线程解决的仅仅是处理数据，但在此处仍需要等待
                Socket accept = serverSocket.accept();
                new Thread(() -> {
                    try {
                        InputStream inputStream = accept.getInputStream();
                        byte[] bytes = new byte[1024];
                        int read = inputStream.read(bytes);
                        String str = new String(bytes,0,read);
                        System.out.println("接收到的内容："+str);
                        Thread.sleep(5000);
                        System.out.println("内容处理线程执行完毕，约耗时5秒");
                    } catch (IOException e) {
                        e.printStackTrace();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }).start();
                System.out.println("服务端本次等待结束，准备监听下次请求");
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            serverSocket.close();
        }

    }
}
public class TcpClientThread {
    public static void main(String[] args) throws IOException {
        System.out.println("tcp协议：客户端启动");
        Socket socket = new Socket("127.0.0.1",8080);
        OutputStream outputStream = socket.getOutputStream();
        byte[] bytes = "我是洺润Star".getBytes();
        outputStream.write(bytes);
        socket.close();
    }
}

1.4 使用线程池管理线程

/**
 * @Auther: 洺润Star
 * @Date: 2020/3/8 14:53
 * @Description:使用线程池改善tcp服务端
 */
class TcpServerThreadPool {
    public static void main(String[] args) throws IOException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        System.out.println("tcp协议：服务端启动");
        ServerSocket serverSocket = new ServerSocket(8080);
        try {
            while (true){
                Socket accept = serverSocket.accept();
                executorService.execute(() -> {
                    try {
                        InputStream inputStream = accept.getInputStream();
                        byte[] bytes = new byte[1024];
                        int read = inputStream.read(bytes);
                        String s = new String(bytes, 0, read);
                        System.out.println("接收到的内容："+s);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            serverSocket.close();
        }

    }
}
public class TcpClientThreadPool {
    public static void main(String[] args) throws IOException {
        System.out.println("tcp协议：客户端启动");
        Socket socket = new Socket("127.0.0.1",8080);
        OutputStream outputStream = socket.getOutputStream();
        byte[] bytes = "我是洺润Star".getBytes();
        outputStream.write(bytes);
        socket.close();
    }
}

1.5 IO模型关系

同步阻塞I/O(BIO)伪异步I/O同步非阻塞I/O（NIO）异步非阻塞I/O(AIO)
客户端个数：I/O线程1：1M:N(其中M可以大于N)M:1(一个IO线程处理多个客户端连接)M:0(不需要启动额外的IO线程，被动回调)
I/O类型（阻塞）阻塞IO阻塞IO非阻塞IO非阻塞IO

1.6 什么是阻塞

阻塞概念:应用程序在获取网络数据的时候,如果网络传输很慢,那么程序就一直等着,直接到传输完毕。

1.7 什么是非阻塞

应用程序直接可以获取已经准备好的数据,无需等待.
IO为同步阻塞形式,NIO为同步非阻塞形式。NIO没有实现异步,在JDK1.7之后，升级了NIO库包,支持异步非阻塞通讯模型NIO2.0(AIO)

1.8 NIO非阻塞代码

//nio   异步非阻塞
class Client {

	public static void main(String[] args) throws IOException {
		System.out.println("客户端已经启动....");
		// 1.创建通道
		SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 8080));
		// 2.切换异步非阻塞
		sChannel.configureBlocking(false);
		// 3.指定缓冲区大小
		ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
		Scanner scanner=  new Scanner(System.in);
		while (scanner.hasNext()) {
			String str=scanner.next();
			byteBuffer.put((new Date().toString()+"\n"+str).getBytes());
			// 4.切换读取模式
			byteBuffer.flip();
			sChannel.write(byteBuffer);
			byteBuffer.clear();
		}
		sChannel.close();
	}

}

// nio
class Server {
	public static void main(String[] args) throws IOException {
		System.out.println("服务器端已经启动....");
		// 1.创建通道
		ServerSocketChannel sChannel = ServerSocketChannel.open();
		// 2.切换读取模式
		sChannel.configureBlocking(false);
		// 3.绑定连接
		sChannel.bind(new InetSocketAddress(8080));
		// 4.获取选择器
		Selector selector = Selector.open();
		// 5.将通道注册到选择器 "并且指定监听接受事件"
		sChannel.register(selector, SelectionKey.OP_ACCEPT);
		// 6. 轮训式 获取选择 "已经准备就绪"的事件
		while (selector.select() > 0) {
			// 7.获取当前选择器所有注册的"选择键(已经就绪的监听事件)"
			Iterator<SelectionKey> it = selector.selectedKeys().iterator();
			while (it.hasNext()) {
				// 8.获取准备就绪的事件
				SelectionKey sk = it.next();
				// 9.判断具体是什么事件准备就绪
				if (sk.isAcceptable()) {
					// 10.若"接受就绪",获取客户端连接
					SocketChannel socketChannel = sChannel.accept();
					// 11.设置阻塞模式
					socketChannel.configureBlocking(false);
					// 12.将该通道注册到服务器上
					socketChannel.register(selector, SelectionKey.OP_READ);
				} else if (sk.isReadable()) {
					// 13.获取当前选择器"就绪" 状态的通道
					SocketChannel socketChannel = (SocketChannel) sk.channel();
					// 14.读取数据
					ByteBuffer buf = ByteBuffer.allocate(1024);
					int len = 0;
					while ((len = socketChannel.read(buf)) > 0) {
						buf.flip();
						System.out.println(new String(buf.array(), 0, len));
						buf.clear();
					}
				}
				it.remove();
			}
		}

	}
}

1.9 选择KEY

在SelectionKey类的源码中我们可以看到如下的4中属性，四个变量用来表示四种不同类型的事件：可连接、可接受连接、可读、可写

  1. SelectionKey.OP_CONNECT
  2. SelectionKey.OP_ACCEPT
  3. SelectionKey.OP_READ
  4. SelectionKey.OP_WRITE

如果要使用多个事件，那么可以用“位或”操作符将常量连接起来，如下：

int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;

2. Netty快速入门

2.1 什么是Netty

Netty 是一个基于 JAVA NIO 类库的异步通信框架，它的架构特点是：异步非阻塞、基于事件驱动、高性能、高可靠性和高可定制性。

2.2 Netty应用场景

  1. 分布式开源框架中dubbo、Zookeeper，RocketMQ底层rpc通讯使用就是netty。
  2. 游戏开发中，底层使用netty通讯。

2.3 为什么选择netty

在本小节，我们总结下为什么不建议开发者直接使用JDK的NIO类库进行开发的原因：

  1. NIO的类库和API繁杂，使用麻烦，你需要熟练掌握Selector、ServerSocketChannel、SocketChannel、ByteBuffer等；
  2. 需要具备其它的额外技能做铺垫，例如熟悉Java多线程编程，因为NIO编程涉及到Reactor模式，你必须对多线程和网路编程非常熟悉，才能编写出高质量的NIO程序；
  3. 可靠性能力补齐，工作量和难度都非常大。例如客户端面临断连重连、网络闪断、半包读写、失败缓存、网络拥塞和异常码流的处理等等，NIO编程的特点是功能开发相对容易，但是可靠性能力补齐工作量和难度都非常大；
  4. JDK NIO的BUG，例如臭名昭著的epoll bug，它会导致Selector空轮询，最终导致CPU 100%。官方声称在JDK1.6版本的update18修复了该问题，但是直到JDK1.7版本该问题仍旧存在，只不过该bug发生概率降低了一些而已，它并没有被根本解决。

2.4 Netty服务器端

先导入倚赖：

<dependency>
	<groupId>io.netty</groupId>
	<artifactId>netty</artifactId>
	<version>3.3.0.Final</version>
</dependency>

package nio.netty;

import org.jboss.netty.bootstrap.ServerBootstrap;
import org.jboss.netty.channel.*;
import org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory;
import org.jboss.netty.handler.codec.string.StringDecoder;
import org.jboss.netty.handler.codec.string.StringEncoder;

import java.net.InetSocketAddress;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @Auther: 洺润Star
 * @Date: 2020/3/10 15:19
 * @Description:netty服务端
 */
class ServerHandler extends SimpleChannelHandler {
    /**
     * 通道关闭的时候触发
     */
    @Override
    public void channelClosed(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
        System.out.println("channelClosed");
    }

    /**
     * 通道关闭的时候触发(必须是已经建立了连接才会触发)
     */
    @Override
    public void channelDisconnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
        super.channelDisconnected(ctx, e);
        System.out.println("channelDisconnected");
    }

    /**
     * 捕获异常
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception {
        super.exceptionCaught(ctx, e);
        System.out.println("exceptionCaught");

    }

    /**
     * 接受消息
     */
    public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
        super.messageReceived(ctx, e);
//		System.out.println("messageReceived");
        System.out.println("服务器端收到客户端消息:"+e.getMessage());
        //回复内容
        ctx.getChannel().write("你好"+e.getMessage());
    }
}

public class NettyServer {
    public static void main(String[] args) {
        //1.创建服务类对象
        ServerBootstrap serverBootstrap = new ServerBootstrap();
        //2.创建两个线程池分别监听端口和nio
        ExecutorService boos = Executors.newCachedThreadPool();
        ExecutorService worker = Executors.newCachedThreadPool();
        //3.设置工厂添加两个线程池
        serverBootstrap.setFactory(new NioServerSocketChannelFactory(boos,worker));
        //4.设置管道工厂
        serverBootstrap.setPipelineFactory(new ChannelPipelineFactory() {
            @Override
            public ChannelPipeline getPipeline() throws Exception {
                ChannelPipeline pipeline = Channels.pipeline();
                //将数据转换为string类型.
                pipeline.addLast("decoder", new StringDecoder());
                pipeline.addLast("encoder", new StringEncoder());
                pipeline.addLast("serverHandler", new ServerHandler());
                return pipeline;
            }
        });
        //5.绑定端口号
        serverBootstrap.bind(new InetSocketAddress(8080));
        System.out.println("netty server启动....");
    }
}

现在如果在主方法结尾在加上这样一段代码：

  while (true){
      try {
          Thread.sleep(1000);
          System.out.println("每隔一秒打印");
      } catch (InterruptedException e) {
          e.printStackTrace();
      }
  }

启动后使用浏览器访问，就会发现服务端对客户端的监听不会造成阻塞，服务端不仅能正常接收到浏览器的请求，输出语句也可以正常打印，由此证明netty框架是非阻塞的。

2.5 Netty客户端

package nio.netty;

import org.jboss.netty.bootstrap.ClientBootstrap;
import org.jboss.netty.channel.*;
import org.jboss.netty.channel.socket.nio.NioClientSocketChannelFactory;
import org.jboss.netty.handler.codec.string.StringDecoder;
import org.jboss.netty.handler.codec.string.StringEncoder;

import java.net.InetSocketAddress;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @Auther: 洺润Star
 * @Date: 2020/3/10 15:31
 * @Description:netty客户端
 */

class ClientHandler extends SimpleChannelHandler {


    /**
     * 通道关闭的时候触发
     */
    @Override
    public void channelClosed(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
        System.out.println("channelClosed");
    }

    /**
     * 通道关闭的时候触发(必须是已经建立了连接才会触发)
     */
    @Override
    public void channelDisconnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
        super.channelDisconnected(ctx, e);
        System.out.println("channelDisconnected");
    }

    /**
     * 捕获异常
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception {
        super.exceptionCaught(ctx, e);
        System.out.println("exceptionCaught");

    }

    /**
     * 接受消息
     */
    public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
        super.messageReceived(ctx, e);
//		System.out.println("messageReceived");
        System.out.println("服务器端向客户端回复内容:"+e.getMessage());
        //回复内容
//		ctx.getChannel().write("好的");
    }

}
public class NettyClient {
    public static void main(String[] args) {
        System.out.println("netty client启动...");
        // 1. 创建客户端类
        ClientBootstrap clientBootstrap = new ClientBootstrap();
        // 2. 创建两个线程池监听端口和nio
        ExecutorService boos = Executors.newCachedThreadPool();
        ExecutorService worker = Executors.newCachedThreadPool();
        //3.设置工厂
        clientBootstrap.setFactory(new NioClientSocketChannelFactory(boos, worker));
        clientBootstrap.setPipelineFactory(new ChannelPipelineFactory() {

            public ChannelPipeline getPipeline() throws Exception {
                ChannelPipeline pipeline = Channels.pipeline();
                // 将数据转换为string类型.
                pipeline.addLast("decoder", new StringDecoder());
                pipeline.addLast("encoder", new StringEncoder());
                pipeline.addLast("clientHandler", new ClientHandler());
                return pipeline;
            }
        });
        //连接服务端
        ChannelFuture connect = clientBootstrap.connect(new InetSocketAddress("127.0.0.1", 8080));
        Channel channel = connect.getChannel();
        System.out.println("client start");
        Scanner scanner=new Scanner(System.in);
        while (true){
            System.out.println("请输输入内容:");
            channel.write(scanner.next());
        }
    }
}

启动服务端和客户端，客户端输入消息，服务端回复消息：
在这里插入图片描述
在这里插入图片描述
如果连接后停止客户端或服务端程序就会打印如下信息：
在这里插入图片描述

洺润
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java NIO的netty实现
一只小菜鸡
08-13 378
  服务端： package netty; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelOption; import io...
Netty（一）
qq_34800986的博客
12-27 233
Netty介绍 Netty是由JBOSS提供的一个java开源框架，现为Github上独立的项目。 一个异步事件驱动的网络应用程序框架，用于快速开发高性能、高可靠性的IO网络框架。 Netty主要针对在TCP协议下，面向Clients端的高并发应用，或者Peer-to-Peer场景下的大量数据传输的应用 Netty本质是一个NIO框架，适用于服务器通讯的相关业务场景 Netty 的应用场景 ...
java nio netty
jihadwk的专栏
05-16 540
由于工作接触到了java nio netty框架，所以就决定学习一下，简单做一个笔记，方便复习 reactor是一种事件分离模式 Netty使用ChannelBuffer来存储并操作读写的网络数据。ChannelBuffer除了提供和ByteBuffer类似的方法，还提供了 一些实用方法，具体可参考其API文档。ChannelBuffer的实现类有多个，这里列举其中主要
NIO 与 Netty
m0_50180963的博客
04-30 1129
NIO 什么是 NIO NIO全称Non Blocking IO，同步非阻塞IO框架。服务器实现模式为一个线程可以处理多个请求(连接)，客户端发送的连接请求都会注册到多路复用器selector上，多路复用器轮询到连接有IO请求就进行处理 为什么用 NIO 常见的网络服务中，如果每一个客户端都维持一个与登陆服务器的连接。那么服务器将维护多个和客户端的连接以出来和客户端的contnect 、read、write ，特别是对于长链接的服务，有多少个c端，就需要在s端维护同等的IO连接。这对服务器来说
NIO模型netty
qq_43470725的博客
06-29 72
Nio三大核心部分：selector(选择器)、channel(通道)、buffer（缓冲区） 学底层思维：万物皆对象，抽象出的类，其有接口和父类，类之间的重写关系建立其其部件之间的联系，好比动物神经；而类的方法（包括构造）和属性是该类的功能实现；属性就是数据结构的体现了，好比做东西的材质，只有合适的材质，没有万能的；总之：类关系，类功能，类属性组合成其想成的所有东西，实现所有功能； ...
详细介绍 NIO与Netty编程-实战讲义详细pdf.7z
03-09
NIO与Netty编程-课程讲义，包含 BIO、NIO、Io的介绍，NIO网络聊天的案列，自定义RPC的实现与设计
深入Hotspot源码与Linux内核理解NIO与Netty线程模型.pdf
03-14
深入Hotspot源码与Linux内核理解NIO与Netty线程模型
nio、bio、netty的一些案例
01-19
该资源中包含了bio、nio、netty的一些常用案例，还有一些Reactor模型的案例。例如：群聊功能、WebSocket长连接的群聊，以及tcp在传输过程中的粘包、拆包问题模拟与解决。
NIO网络编程原理与实战.xmind
05-26
https://blog.csdn.net/ykmeory/article/details/115603895
NIO框架Netty实现高性能高并发
05-15
Java异步NIO框架Netty实现高性能高并发无标题笔记 1. 背景 1.1. 惊人的性能数据 最近一个圈内朋友通过私信告诉我，通过使用Netty4 + Thrift压缩二进制编解码技术，他们实现了10W TPS（1K的复杂POJO对象）的跨 节点远程服务调用。相比于传统基于Java序列化+BIO（同步阻塞IO）的通信框架，性能提升了8倍多。 事实上，我对这个数据并不感到惊讶，根据我5年多的NIO编程经验，通过选择合适的NIO框架，加上高性能的压缩二进制编解码技术，精 心的设计Reactor线程模型，达到上述性能指标是完全有可能的。 下面我们就一起来看下Netty是如何支持10W TPS的跨节点远程服务调用的，在正式开始讲解之前，我们先简单介绍下Netty。
NIO Netty使用入门
一休哥
05-12 562
Netty是什么？ 本质：JBoss做的一个Jar包 目的：快速开发高性能、高可靠性的网络服务器和客户端程序 优点：提供异步的、事件驱动的网络应用程序框架和工具 通俗的说：一个好使的处理Socket的东东 Netty的特性 设计 统一的API，适用于不同的协议（阻塞和非阻塞） 基于灵活、可扩展的事件驱动模型 高度可定制的线程模型 可靠的无
netty 之nio
架构师的成长之路的博客
06-08 1183
netty 之nio传统IOIO特点 * 阻塞点 server.accept(); inputStream.read(bytes);单线程情况下只能有一个客户端用线程池可以有多个客户端连接，但是非常消耗性能public class OioServerOne { @SuppressWarnings("resource") public static void main(String[] arg...
基于NIO简单实现Netty
长河的博客
09-09 645
具体是过程如下: 初始化两个线程池,boss负责链接,work负责连接的处理 初始化boss线程池大小为1 调用构造方法,进行赋值,调用Selector.open(); 获取当前线程池的selector 执行线程任务,分别是设置未连接的状态,查看是否已经有链接到来, 执行队列里的任务,处理selector中的内容,如果不为空就获取一个work线程,添加到work的任务队列中去 ...
Netty与NIO
qq_30118563的博客
05-12 5210
Linux的 网络IO 一、简介 1、Linux上所有外部设备都抽象为file。 2、对一个文件的读写会调用kernel命令，返回file descriptor (fd)； 3、对一个socket的读写会调用kernel命令，返回socketfd 4、描述符实际就是一个数字，指向内核中一个结构体（文件路径、数据区等一些属性） 二、Linux 对Socket IO模型的抽象 ...
NIO流行框架 Netty
lm324114的专栏
03-09 680
Netty 实现通信的步骤： 1.创建两个NIO线程组，一个专门用于网络事件处理（接受客户端的连接），另一个则进行网络通信读写。 2.创建一个ServerBootstrap对象，配置Netty的一系列参数，例如接受传出数据的缓存大小等。 3.创建一个实际处理数据的类Channellnitalizer，进行初始化的准备工作，比如设置接受传出数据的字符 格式 以及实际处理数据的接口 4.绑定接
什么是NIO，什么是Netty
最新发布
islautao的博客
06-04 761
本文简单介绍了NIO和Netty的概念、特点和区别，并给出了一些示例和插图。希望对你有所帮助。
NIO编程（netty的使用）
qq_33012981的博客
09-21 166
NIO编程（netty的使用） 1.传统io（使用socket网络编程测试） 服务端监听客户端发送的数据 public class IOServer { public static void main(String[] args) throws IOException { // ServerSocket serverSocket = new ServerSocket(9002); while (true){ //用阻塞方法获取
io 错误: socket read timed out_网络编程IO、NIO与Netty
06-02
这个错误是指在进行网络编程中，读取socket数据时发生了超时。这种情况通常发生在网络连接不稳定或数据传输过程中出现了问题。要解决这个问题，可以考虑以下几点： 1. 检查网络连接是否正常，确保网络稳定。 2. 调整读取超时时间，增加读取数据的等待时间，避免出现超时的情况。 3. 通过使用非阻塞IO（NIO）或使用Netty等网络编程框架来提高程序的性能和可靠性。 4. 在读取数据时使用缓冲区，减少数据传输过程中的延迟，提高效率。 总之，网络编程中出现的IO错误需要仔细排查问题，找到根本原因并及时解决。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值