超详细Netty入门，看这篇就够了！

news2024/9/22 19:33:48

简介：
本文主要讲述Netty框架的一些特性以及重要组件，希望看完之后能对Netty框架有一个比较直观的感受，希望能帮助读者快速入门Netty，减少一些弯路。
在这里插入图片描述

前言

本文主要讲述Netty框架的一些特性以及重要组件，希望看完之后能对Netty框架有一个比较直观的感受，希望能帮助读者快速入门Netty，减少一些弯路。

一、Netty概述

官方的介绍：

Netty is an asynchronous event-driven network application framework
for rapid development of maintainable high performance protocol servers & clients.

Netty是 一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。

二、为什么使用Netty

从官网上介绍，Netty是一个网络应用程序框架，开发服务器和客户端。也就是用于网络编程的一个框架。既然是网络编程，Socket就不谈了，为什么不用NIO呢？

2.1 NIO的缺点
对于这个问题，之前我写了一篇文章《NIO入门》对NIO有比较详细的介绍，NIO的主要问题是：

NIO的类库和API繁杂，学习成本高，你需要熟练掌握Selector、ServerSocketChannel、SocketChannel、ByteBuffer等。
需要熟悉Java多线程编程。这是因为NIO编程涉及到Reactor模式，你必须对多线程和网络编程非常熟悉，才能写出高质量的NIO程序。
臭名昭著的epoll bug。它会导致Selector空轮询，最终导致CPU 100%。直到JDK1.7版本依然没得到根本性的解决。
2.2 Netty的优点
相对地，Netty的优点有很多：

API使用简单，学习成本低。
功能强大，内置了多种解码编码器，支持多种协议。
性能高，对比其他主流的NIO框架，Netty的性能最优。
社区活跃，发现BUG会及时修复，迭代版本周期短，不断加入新的功能。
Dubbo、Elasticsearch都采用了Netty，质量得到验证。

三、架构图

image.png

上面这张图就是在官网首页的架构图，我们从上到下分析一下。

绿色的部分Core核心模块，包括零拷贝、API库、可扩展的事件模型。

橙色部分Protocol Support协议支持，包括Http协议、webSocket、SSL(安全套接字协议)、谷歌Protobuf协议、zlib/gzip压缩与解压缩、Large File Transfer大文件传输等等。

红色的部分Transport Services传输服务，包括Socket、Datagram、Http Tunnel等等。

以上可看出Netty的功能、协议、传输方式都比较全，比较强大。

四、永远的Hello Word

首先搭建一个HelloWord工程，先熟悉一下API，还有为后面的学习做铺垫。以下面这张图为依据：

在这里插入图片描述

4.1 引入Maven依赖
使用的版本是4.1.20，相对比较稳定的一个版本。

![<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.20.Final</version>
</dependency>](https://img-blog.csdnimg.cn/6fcf65c9c9d449fb88a4b6dc29333c3f.png)

4.2 创建服务端启动类

public class MyServer {
    public static void main(String[] args) throws Exception {
        //创建两个线程组 boosGroup、workerGroup
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            //创建服务端的启动对象，设置参数
            ServerBootstrap bootstrap = new ServerBootstrap();
            //设置两个线程组boosGroup和workerGroup
            bootstrap.group(bossGroup, workerGroup)
                //设置服务端通道实现类型
                .channel(NioServerSocketChannel.class)
                //设置线程队列得到连接个数
                .option(ChannelOption.SO_BACKLOG, 128)
                //设置保持活动连接状态
                .childOption(ChannelOption.SO_KEEPALIVE, true)
                //使用匿名内部类的形式初始化通道对象
                .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            //给pipeline管道设置处理器
                            socketChannel.pipeline().addLast(new MyServerHandler());
                        }
                    });//给workerGroup的EventLoop对应的管道设置处理器
            System.out.println("java技术爱好者的服务端已经准备就绪...");
            //绑定端口号，启动服务端
            ChannelFuture channelFuture = bootstrap.bind(6666).sync();
            //对关闭通道进行监听
            channelFuture.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

4.3 创建服务端处理器

/**
 * 自定义的Handler需要继承Netty规定好的HandlerAdapter
 * 才能被Netty框架所关联，有点类似SpringMVC的适配器模式
 **/
public class MyServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //获取客户端发送过来的消息
        ByteBuf byteBuf = (ByteBuf) msg;
        System.out.println("收到客户端" + ctx.channel().remoteAddress() + "发送的消息：" + byteBuf.toString(CharsetUtil.UTF_8));
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        //发送消息给客户端
        ctx.writeAndFlush(Unpooled.copiedBuffer("服务端已收到消息，并给你发送一个问号?", CharsetUtil.UTF_8));
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        //发生异常，关闭通道
        ctx.close();
    }
}

4.4 创建客户端启动类

public class MyClient {

    public static void main(String[] args) throws Exception {
        NioEventLoopGroup eventExecutors = new NioEventLoopGroup();
        try {
            //创建bootstrap对象，配置参数
            Bootstrap bootstrap = new Bootstrap();
            //设置线程组
            bootstrap.group(eventExecutors)
                //设置客户端的通道实现类型
                .channel(NioSocketChannel.class)
                //使用匿名内部类初始化通道
                .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            //添加客户端通道的处理器
                            ch.pipeline().addLast(new MyClientHandler());
                        }
                    });
            System.out.println("客户端准备就绪，随时可以起飞~");
            //连接服务端
            ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 6666).sync();
            //对通道关闭进行监听
            channelFuture.channel().closeFuture().sync();
        } finally {
            //关闭线程组
            eventExecutors.shutdownGracefully();
        }
    }
}

4.5 创建客户端处理器

public class MyClientHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //发送消息到服务端
        ctx.writeAndFlush(Unpooled.copiedBuffer("歪比巴卜~茉莉~Are you good~马来西亚~", CharsetUtil.UTF_8));
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //接收服务端发送过来的消息
        ByteBuf byteBuf = (ByteBuf) msg;
        System.out.println("收到服务端" + ctx.channel().remoteAddress() + "的消息：" + byteBuf.toString(CharsetUtil.UTF_8));
    }
}

4.6 测试
先启动服务端，再启动客户端，就可以看到结果：

MyServer打印结果:

image.png

MyClient打印结果：
image.png

五、Netty的特性与重要组件

5.1 taskQueue任务队列
如果Handler处理器有一些长时间的业务处理，可以交给taskQueue异步处理。怎么用呢，请看代码演示：

public class MyServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //获取到线程池eventLoop，添加线程，执行
        ctx.channel().eventLoop().execute(new Runnable() {
            @Override
            public void run() {
                try {
                    //长时间操作，不至于长时间的业务操作导致Handler阻塞
                    Thread.sleep(1000);
                    System.out.println("长时间的业务处理");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

我们打一个debug调试，是可以看到添加进去的taskQueue有一个任务。

image.png

5.2 scheduleTaskQueue延时任务队列
延时任务队列和上面介绍的任务队列非常相似，只是多了一个可延迟一定时间再执行的设置，请看代码演示：

ctx.channel().eventLoop().schedule(new Runnable() {
    @Override
    public void run() {
        try {
            //长时间操作，不至于长时间的业务操作导致Handler阻塞
            Thread.sleep(1000);
            System.out.println("长时间的业务处理");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
},5, TimeUnit.SECONDS);//5秒后执行

依然打开debug进行调试查看，我们可以有一个scheduleTaskQueue任务待执行中

5.3 Future异步机制
在搭建HelloWord工程的时候，我们看到有一行这样的代码：

ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 6666);

很多操作都返回这个ChannelFuture对象，究竟这个ChannelFuture对象是用来做什么的呢？

ChannelFuture提供操作完成时一种异步通知的方式。一般在Socket编程中，等待响应结果都是同步阻塞的，而Netty则不会造成阻塞，因为ChannelFuture是采取类似观察者模式的形式进行获取结果。请看一段代码演示：

//添加监听器
channelFuture.addListener(new ChannelFutureListener() {
    //使用匿名内部类，ChannelFutureListener接口
    //重写operationComplete方法
    @Override
    public void operationComplete(ChannelFuture future) throws Exception {
        //判断是否操作成功
        if (future.isSuccess()) {
            System.out.println("连接成功");
        } else {
            System.out.println("连接失败");
        }
    }
});

5.4 Bootstrap与ServerBootStrap
Bootstrap和ServerBootStrap是Netty提供的一个创建客户端和服务端启动器的工厂类，使用这个工厂类非常便利地创建启动类，根据上面的一些例子，其实也看得出来能大大地减少了开发的难度。首先看一个类图：

image.png

可以看出都是继承于AbstractBootStrap抽象类，所以大致上的配置方法都相同。

一般来说，使用Bootstrap创建启动器的步骤可分为以下几步：

image.png

5.4.1 group()
在上一篇文章《Reactor模式》中，我们就讲过服务端要使用两个线程组：

bossGroup 用于监听客户端连接，专门负责与客户端创建连接，并把连接注册到workerGroup的Selector中。
workerGroup用于处理每一个连接发生的读写事件。
一般创建线程组直接使用以下new就完事了：

EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();

有点好奇的是，既然是线程组，那线程数默认是多少呢？深入源码：

 //使用一个常量保存
    private static final int DEFAULT_EVENT_LOOP_THREADS;

    static {
        //NettyRuntime.availableProcessors() * 2，cpu核数的两倍赋值给常量
        DEFAULT_EVENT_LOOP_THREADS = Math.max(1, SystemPropertyUtil.getInt(
                "io.netty.eventLoopThreads", NettyRuntime.availableProcessors() * 2));

        if (logger.isDebugEnabled()) {
            logger.debug("-Dio.netty.eventLoopThreads: {}", DEFAULT_EVENT_LOOP_THREADS);
        }
    }

    protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) {
        //如果不传入，则使用常量的值，也就是cpu核数的两倍
        super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args);
    }

通过源码可以看到，默认的线程数是cpu核数的两倍。假设想自定义线程数，可以使用有参构造器：

//设置bossGroup线程数为1
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
//设置workerGroup线程数为16
EventLoopGroup workerGroup = new NioEventLoopGroup(16);

5.4.2 channel()
这个方法用于设置通道类型，当建立连接后，会根据这个设置创建对应的Channel实例。

使用debug模式可以看到

通道类型有以下：

NioSocketChannel： 异步非阻塞的客户端 TCP Socket 连接。

NioServerSocketChannel： 异步非阻塞的服务器端 TCP Socket 连接。

常用的就是这两个通道类型，因为是异步非阻塞的。所以是首选。

OioSocketChannel： 同步阻塞的客户端 TCP Socket 连接。

OioServerSocketChannel： 同步阻塞的服务器端 TCP Socket 连接。

稍微在本地调试过，用起来和Nio有一些不同，是阻塞的，所以API调用也不一样。因为是阻塞的IO，几乎没什么人会选择使用Oio，所以也很难找到例子。我稍微琢磨了一下，经过几次报错之后，总算调通了。代码如下：

//server端代码，跟上面几乎一样，只需改三个地方
//这个地方使用的是OioEventLoopGroup
EventLoopGroup bossGroup = new OioEventLoopGroup();
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(bossGroup)//只需要设置一个线程组boosGroup
        .channel(OioServerSocketChannel.class)//设置服务端通道实现类型

//client端代码，只需改两个地方
//使用的是OioEventLoopGroup
EventLoopGroup eventExecutors = new OioEventLoopGroup();
//通道类型设置为OioSocketChannel
bootstrap.group(eventExecutors)//设置线程组
        .channel(OioSocketChannel.class)//设置客户端的通道实现类型

NioSctpChannel： 异步的客户端 Sctp（Stream Control Transmission Protocol，流控制传输协议）连接。

NioSctpServerChannel： 异步的 Sctp 服务器端连接。

本地没启动成功，网上看了一些网友的评论，说是只能在linux环境下才可以启动。从报错信息看：SCTP not supported on this platform，不支持这个平台。因为我电脑是window系统，所以网友说的有点道理。

5.4.3 option()与childOption()
首先说一下这两个的区别。

option()设置的是服务端用于接收进来的连接，也就是boosGroup线程。

childOption()是提供给父管道接收到的连接，也就是workerGroup线程。

搞清楚了之后，我们看一下常用的一些设置有哪些：

SocketChannel参数，也就是childOption()常用的参数：

SO_RCVBUF Socket参数，TCP数据接收缓冲区大小。
TCP_NODELAY TCP参数，立即发送数据，默认值为Ture。
SO_KEEPALIVE Socket参数，连接保活，默认值为False。启用该功能时，TCP会主动探测空闲连接的有效性。

ServerSocketChannel参数，也就是option()常用参数：

SO_BACKLOG Socket参数，服务端接受连接的队列长度，如果队列已满，客户端连接将被拒绝。默认值，Windows为200，其他为128。

由于篇幅限制，其他就不列举了，大家可以去网上找资料看看，了解一下。

5.4.4 设置流水线(重点)
ChannelPipeline是Netty处理请求的责任链，ChannelHandler则是具体处理请求的处理器。实际上每一个channel都有一个处理器的流水线。

在Bootstrap中childHandler()方法需要初始化通道，实例化一个ChannelInitializer，这时候需要重写initChannel()初始化通道的方法，装配流水线就是在这个地方进行。代码演示如下：

//使用匿名内部类的形式初始化通道对象
bootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        //给pipeline管道设置自定义的处理器
        socketChannel.pipeline().addLast(new MyServerHandler());
    }
});

处理器Handler主要分为两种：

ChannelInboundHandlerAdapter(入站处理器)、ChannelOutboundHandler(出站处理器)

入站指的是数据从底层java NIO Channel到Netty的Channel。

出站指的是通过Netty的Channel来操作底层的java NIO Channel。

ChannelInboundHandlerAdapter处理器常用的事件有：

  1. 注册事件 fireChannelRegistered。

  2. 连接建立事件 fireChannelActive。

  3. 读事件和读完成事件 fireChannelRead、fireChannelReadComplete。

  4. 异常通知事件 fireExceptionCaught。

  5. 用户自定义事件 fireUserEventTriggered。

  6. Channel 可写状态变化事件 fireChannelWritabilityChanged。

  7. 连接关闭事件 fireChannelInactive。
    ChannelOutboundHandler处理器常用的事件有：

  8. 端口绑定 bind。

  9. 连接服务端 connect。

  10. 写事件 write。

  11. 刷新时间 flush。

  12. 读事件 read。

  13. 主动断开连接 disconnect。

  14. 关闭 channel 事件 close。
    还有一个类似的handler()，主要用于装配parent通道，也就是bossGroup线程。一般情况下，都用不上这个方法。

5.4.5 bind()
提供用于服务端或者客户端绑定服务器地址和端口号，默认是异步启动。如果加上sync()方法则是同步。

有五个同名的重载方法，作用都是用于绑定地址端口号。不一一介绍了。

5.4.6 优雅地关闭EventLoopGroup

//释放掉所有的资源，包括创建的线程
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();

会关闭所有的child Channel。关闭之后，释放掉底层的资源。

5.5 Channel
Channel是什么？不妨看一下官方文档的说明：

A nexus to a network socket or a component which is capable of I/O operations such as read, write, connect, and bind

翻译大意：一种连接到网络套接字或能进行读、写、连接和绑定等I/O操作的组件。

如果上面这段说明比较抽象，下面还有一段说明：

A channel provides a user:

the current state of the channel (e.g. is it open? is it connected?),
the configuration parameters of the channel (e.g. receive buffer size),
the I/O operations that the channel supports (e.g. read, write, connect, and bind), and
the ChannelPipeline which handles all I/O events and requests associated with the channel.

翻译大意：

channel为用户提供：

通道当前的状态（例如它是打开？还是已连接？）
channel的配置参数（例如接收缓冲区的大小）
channel支持的IO操作（例如读、写、连接和绑定），以及处理与channel相关联的所有IO事件和请求的ChannelPipeline。
5.5.1 获取channel的状态

boolean isOpen(); //如果通道打开，则返回true
boolean isRegistered();//如果通道注册到EventLoop，则返回true
boolean isActive();//如果通道处于活动状态并且已连接，则返回true
boolean isWritable();//当且仅当I/O线程将立即执行请求的写入操作时，返回true。

以上就是获取channel的四种状态的方法。

5.5.2 获取channel的配置参数
获取单条配置信息，使用getOption()，代码演示：

ChannelConfig config = channel.config();//获取配置参数
//获取ChannelOption.SO_BACKLOG参数,
Integer soBackLogConfig = config.getOption(ChannelOption.SO_BACKLOG);
//因为我启动器配置的是128，所以我这里获取的soBackLogConfig=128

获取多条配置信息，使用getOptions()，代码演示：

ChannelConfig config = channel.config();
Map<ChannelOption<?>, Object> options = config.getOptions();
for (Map.Entry<ChannelOption<?>, Object> entry : options.entrySet()) {
    System.out.println(entry.getKey() + " : " + entry.getValue());
}
/**
SO_REUSEADDR : false
WRITE_BUFFER_LOW_WATER_MARK : 32768
WRITE_BUFFER_WATER_MARK : WriteBufferWaterMark(low: 32768, high: 65536)
SO_BACKLOG : 128
以下省略...
*/

5.5.3 channel支持的IO操作
写操作，这里演示从服务端写消息发送到客户端：

@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
    ctx.channel().writeAndFlush(Unpooled.copiedBuffer("这波啊，这波是肉蛋葱鸡~", CharsetUtil.UTF_8));
}

客户端控制台：

//收到服务端/127.0.0.1:6666的消息：这波啊，这波是肉蛋葱鸡~

连接操作，代码演示：

ChannelFuture connect = channelFuture.channel().connect(new InetSocketAddress("127.0.0.1", 6666));//一般使用启动器，这种方式不常用

通过channel获取ChannelPipeline，并做相关的处理：

//获取ChannelPipeline对象
ChannelPipeline pipeline = ctx.channel().pipeline();
//往pipeline中添加ChannelHandler处理器，装配流水线
pipeline.addLast(new MyServerHandler());

5.6 Selector
在NioEventLoop中，有一个成员变量selector，这是nio包的Selector，在之前《NIO入门》中，我已经讲过Selector了。

Netty中的Selector也和NIO的Selector是一样的，就是用于监听事件，管理注册到Selector中的channel，实现多路复用器。

image.png

5.7 PiPeline与ChannelPipeline
在前面介绍Channel时，我们知道可以在channel中装配ChannelHandler流水线处理器，那一个channel不可能只有一个channelHandler处理器，肯定是有很多的，既然是很多channelHandler在一个流水线工作，肯定是有顺序的。

于是pipeline就出现了，pipeline相当于处理器的容器。初始化channel时，把channelHandler按顺序装在pipeline中，就可以实现按序执行channelHandler了。

image.png

在一个Channel中，只有一个ChannelPipeline。该pipeline在Channel被创建的时候创建。ChannelPipeline包含了一个ChannelHander形成的列表，且所有ChannelHandler都会注册到ChannelPipeline中。

5.8 ChannelHandlerContext
在Netty中，Handler处理器是有我们定义的，上面讲过通过集成入站处理器或者出站处理器实现。这时如果我们想在Handler中获取pipeline对象，或者channel对象，怎么获取呢。

于是Netty设计了这个ChannelHandlerContext上下文对象，就可以拿到channel、pipeline等对象，就可以进行读写等操作。

image.png

通过类图，ChannelHandlerContext是一个接口，下面有三个实现类。

实际上ChannelHandlerContext在pipeline中是一个链表的形式。看一段源码就明白了：

//ChannelPipeline实现类DefaultChannelPipeline的构造器方法
protected DefaultChannelPipeline(Channel channel) {
    this.channel = ObjectUtil.checkNotNull(channel, "channel");
    succeededFuture = new SucceededChannelFuture(channel, null);
    voidPromise =  new VoidChannelPromise(channel, true);
    //设置头结点head，尾结点tail
    tail = new TailContext(this);
    head = new HeadContext(this);

    head.next = tail;
    tail.prev = head;
}

下面我用一张图来表示，会更加清晰一点：
image.png

5.9 EventLoopGroup
我们先看一下EventLoopGroup的类图：

image.png

其中包括了常用的实现类NioEventLoopGroup。OioEventLoopGroup在前面的例子中也有使用过。

从Netty的架构图中，可以知道服务器是需要两个线程组进行配合工作的，而这个线程组的接口就是EventLoopGroup。

每个EventLoopGroup里包括一个或多个EventLoop，每个EventLoop中维护一个Selector实例。

5.9.1 轮询机制的实现原理
我们不妨看一段DefaultEventExecutorChooserFactory的源码：

private final AtomicInteger idx = new AtomicInteger();
private final EventExecutor[] executors;

@Override
public EventExecutor next() {
    //idx.getAndIncrement()相当于idx++，然后对任务长度取模
    return executors[idx.getAndIncrement() & executors.length - 1];
}

这段代码可以确定执行的方式是轮询机制，接下来debug调试一下：

它这里还有一个判断，如果线程数不是2的N次方，则采用取模算法实现。

@Override
public EventExecutor next() {
    return executors[Math.abs(idx.getAndIncrement() % executors.length)];
}

写在最后
参考Netty官网文档：API文档

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/181966.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

一起自学SLAM算法：10.2 VINS算法

一起自学SLAM算法：10.2 VINS算法

连载文章&#xff0c;长期更新&#xff0c;欢迎关注&#xff1a; 不管是激光SLAM还是视觉SLAM&#xff0c;由于传感器采样率、传感器测量精度、主机计算力等因素的限制&#xff0c;在高速运动状态下定位追踪极易丢失。虽然轮式里程计能为激光SLAM系统提供短期运动预测以避免高速…
阅读更多...
记录一次ubuntu进入不了界面的恢复记录

记录一次ubuntu进入不了界面的恢复记录

能说服一个人的从来不是道理&#xff0c;而是南墙&#xff1b;能点醒一个人的从来不是说教&#xff0c;而是磨难 一、问题描述 1、 卸载Python之后&#xff0c;ubuntu启动进入黑屏tty界面无法联网&#xff0c;无法进入桌面 2、 进入到界面之后没有网络&#xff0c;网络中或者右…
阅读更多...
【分析向】没有三级缓存会导致什么？

【分析向】没有三级缓存会导致什么？

通过上篇&#xff08;【实践向】当移除了三级缓存…… &#xff09;的实践&#xff0c;我们得出的结论是&#xff1a;如果不存在代理对象&#xff0c;二级缓存就可以解决循环依赖性的问题&#xff0c;但是当存在代理对象的时候&#xff0c;二级缓存则无法完全解决循环依赖&…
阅读更多...
机器自动翻译古文拼音 - 十大宋词 - ALL

机器自动翻译古文拼音 - 十大宋词 - ALL

机器自动翻译古文拼音 - 十大宋词 - 雨霖铃寒蝉凄切 柳永https://mp.csdn.net/mp_blog/creation/editor/128779245机器自动翻译古文拼音 - 十大宋词 - 江城子乙卯正月二十日夜记梦 苏轼https://mp.csdn.net/mp_blog/creation/editor/128779156机器自动翻译古文拼音 - 十大宋词 …
阅读更多...
0基础小白十分钟入门人工智能强化学习(附有实战源码)

0基础小白十分钟入门人工智能强化学习(附有实战源码)

强化学习概述 1.1 强化学习的学习任务目标 强化学习&#xff08;Reinforcement Learning, RL&#xff09;&#xff0c;用官话讲&#xff0c;是机器学习的范式和方法论之一&#xff0c;用于描述和解决智能体&#xff08;agent&#xff09;在与环境的交互过程中通过学习策略以达成…
阅读更多...
Mybatis-Plus 乐观锁与代码生成器

Mybatis-Plus 乐观锁与代码生成器

目录 乐观锁 问题引入 乐观锁实现思路 实现步骤 代码生成器 代码生成器分析 代码生成器实现 乐观锁 问题引入 业务并发现象带来的问题:秒杀 假如有100个商品或者票在出售&#xff0c;为了能保证每个商品或者票只能被一个人购买&#xff0c;如何保证不会出现超买或者重复…
阅读更多...
记一次nginx崩溃事件

记一次nginx崩溃事件

一、事件描述 2023年春节复工第一天&#xff0c;项目组同事反馈说业务系统中图像处理代理Nginx服务于1月23日发生崩溃&#xff0c;完成了重启操作&#xff0c;检查nginx的日志有如下报错&#xff1a; 2023/01/23 11:07:07 [crit] 3237#3237: *2253009 pwritev() "/var/c…
阅读更多...
网络编程-----(Socket编程TCP)

网络编程-----(Socket编程TCP)

在咱们的TCP API中&#xff0c;也是主要是涉及到两个类: 1)ServerSocket:主要是给TCP服务器来进行使用的&#xff1b; 2)Socket:我们既需要给客户端来进行使用&#xff0c;也需要给服务器来进行使用&#xff1b; 这样就是说我们是不需要使用专门的类来进行表示传输的包&#x…
阅读更多...
Java学习之抽象模板模式

Java学习之抽象模板模式

目录 一、基本介绍 二、模板设计模式能解决的问题 三、最佳实践 一、AA类 二、BB类 三、main方法实现 四、提取相同语句 五、建立继承关系 父类-Template 子类-AA类 子类-BB类 六、运行中的动态绑定机制 一、基本介绍 抽象类体现的就是一种模板模式的设计&#xff…
阅读更多...
【Git】概述

【Git】概述

目录 1.1 是什么 介绍 历史时间轴 版本控制工具 1.2 能干嘛 作用 Git工作机制 代码托管中心 集中式版本控制系统 分布式版本控制系统 1.3 去哪下 命令行工具&#xff1a;Git for windows 操作系统中可视化工具&#xff1a;TortoiseGit(了解) GitHub网站 1.1 是什…
阅读更多...
带你走进Java8新特性Stream流的小世界

带你走进Java8新特性Stream流的小世界

目录 一. 什么是流&#xff08;Stream&#xff09; 1.1 流的定义 1.2 流的特点 1.3 操作流 1.4 创建流 二. 流的中间操作 2.1 流的筛选与切片 2.1.1 filter 2.1.2 limit 2.1.3 skip 2.1.4 distinct 2.2 流的映射 2.2.1 map 2.2.2 flatMap 2.3 流的排序 2.3.1 s…
阅读更多...
智公网：2023年教师编必背30考点

智公网：2023年教师编必背30考点

1、制度化教育阶段开始于&#xff1a;近代。 2、各国的学校教育系统基本形成于&#xff1a;19世纪末。 3、现在世界上大多数国家的义务教育年限在&#xff1a;9年或9年以上。 4、“不愤不启&#xff0c;不悱不发”启发教学法的最早倡导者是&#xff1a;孔子。 5、“建国君民…
阅读更多...
【Spring】Spring 6 新特性一一HTTP Interface

【Spring】Spring 6 新特性一一HTTP Interface

简介 Spring 6 的第一个 GA 版本发布了&#xff0c;其中带来了一个新的特性——HTTP Interface。 这个新特性&#xff0c;可以让开发者将 HTTP 服务&#xff0c;定义成一个包含特定注解标记的方法的 Java 接口&#xff0c;然后通过对接口方法的调用&#xff0c;完成 HTTP 请求…
阅读更多...
硬盘损坏数据恢复怎么操作？恢复数据的常用方法

硬盘损坏数据恢复怎么操作？恢复数据的常用方法

硬盘一般固定在电脑里面的存储装置&#xff0c;里面保存着我们大量的数据。随着电脑的使用越加广泛&#xff0c;有时不免出现一些问题&#xff0c;比如硬盘在使用过程中出现数据错误&#xff0c;或者是硬盘的内部零件出现故障。出现这些问题&#xff0c;硬盘损坏数据恢复怎么操…
阅读更多...
Redis实现UV统计 | 黑马点评

Redis实现UV统计 | 黑马点评

一、HyperLogLog 1、为什么用HyperLogLog 先介绍两个概念&#xff1a; UV&#xff1a;全称 Unique Visitor&#xff0c;也叫独立访客量&#xff0c;是指通过互联网访问、浏览这个网页的自然人、1 天内同一个用户多次访问该网站&#xff0c;只记录 1 次。PV&#xff1a;全称 …
阅读更多...
车载以太网 - SomeIP测试专栏 - 总纲

车载以太网 - SomeIP测试专栏 - 总纲

关于车载以太网中的SomeIP在网上也逐渐有越来越多的资料，讲的也是非常好；但是个人认为讲的泛，很难让初学者或者初入门者真正了解SomeIP到底是一个什么东西，以及它究竟在车载上有什么作用，本专栏会由浅入深的讲解SomeIP整个协议内容规范，并且对Tc8中SomeIP相关的协议测试用…
阅读更多...
实习日记！

实习日记！

目录 http://localhost:5789实习第三天 接下来几天的target 实习第四天 Git的操作 实习第五天 12月5日-Mon 12月6日 12月9日 12月12日 12月15日 useState() hook 12月16日 useEffect() hook async 函数 异步编程 回调函数 12月17日 C#中的&#xff1f;&#x…
阅读更多...
postgresql源码学习（54）—— HotStandby从库必须设置大于等于主库的参数

postgresql源码学习（54）—— HotStandby从库必须设置大于等于主库的参数

新的一篇本来计划研究lazy_scan_heap函数&#xff0c;但过于复杂还没研究出来… 下午做题遇到一个这样的问题&#xff0c;之前没太关注过&#xff0c;打算学习学习&#xff0c;避免主从配置踩坑。 题干搜一搜&#xff0c;没搜出啥有用的玩意…渣翻成英文搜一搜&#xff0c;搜出…
阅读更多...
windows搭建go语言开发环境，IDEA安装go插件并运行Hello world代码

windows搭建go语言开发环境，IDEA安装go插件并运行Hello world代码

2023年1月27日1.Windows上安装Go语言开发包参考链接&#xff1a;http://c.biancheng.net/view/3992.html1.1.下载Go语言开发包可以在Go语言官网 &#xff08;https://golang.google.cn/dl/&#xff09; 下载Windows 系统下的Go语言开发包&#xff0c;如下图所示。这里我们下载的…
阅读更多...
学习Docker就应该掌握的dockerfile语法与指令

学习Docker就应该掌握的dockerfile语法与指令

在日常的工作中&#xff0c;常常需要制作自己的项目的镜像&#xff0c;一般通过以下两种方式制作镜像&#xff1a;Docker commit、Dockerfile。Docker commitDocker commit一般用做从一个运行状态的容器来创建一个新的镜像。定制镜像应该使用Dockerfile来完成。docker commit 容…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023