【对话写 Netty 代码的同学，你真的懂 Netty 了吗？（三中）】initAndRegister() 之 init() 对不起！！我柜子动了…我不学了

2023-11-02 09:40
文章标签 代码 init 真的 netty 对话 对不起 不学 同学 柜子 initandregister 三中

本文主要是介绍【对话写 Netty 代码的同学，你真的懂 Netty 了吗？（三中）】initAndRegister() 之 init() 对不起！！我柜子动了…我不学了，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

目录：

【对话写 Netty 代码的同学，你真的懂 Netty 了吗？（一）】Netty 初始化总览

【对话写 Netty 代码的同学，你真的懂 Netty 了吗？（二）】主线流程 new NioEventLoopGroup(nThreads) 究竟做了什么

【对话写 Netty 代码的同学，你真的懂 Netty 了吗？（三上）】initAndRegister() 之 init() 怒了！这文章为啥写成了这样？？

【对话写 Netty 代码的同学，你真的懂 Netty 了吗？（三中）】initAndRegister() 之 init() 对不起！！我柜子动了…我不学了

写在前面

欢迎添加个人微信 dyinggq 一起交流学习~~

书接上文：对话写 Netty 代码的同学，你真的懂 Netty 了吗？（三之上）怒了！这文章为啥写成了这样？？

在上篇中，对于 Netty 的第一大部分 initAndRegister() 方法我们拆分为三部分进行讲解

  1. channel = channelFactory.newChannel();
  2. init(channel);
  3. ChannelFuture regFuture = config().group().register(channel);

对于第二小部分的 init(channel) 有些遗漏的地方，故而本篇将从 init 继续讲起。

initAndRegister 之 init(channel)

上篇总结到：

init 其实就是在初始化 NioServerSocketChannel 的各个属性，主要是其 options 和 pipeline 的初始化。

然而在这里对于 pipeline 的初始化有些遗漏，在 ServerBootstrap 的 init 方法中为 pipeline 添加 ChannelInitializer 忽略了一个细节 ch.eventLoop().execute

        ChannelPipeline p = channel.pipeline(); // 这里的 channel 即 NioServerSocketChannelp.addLast(new ChannelInitializer<Channel>() {@Overridepublic void initChannel(final Channel ch) throws Exception {final ChannelPipeline pipeline = ch.pipeline();ChannelHandler handler = config.handler();if (handler != null) {pipeline.addLast(handler);}ch.eventLoop().execute(new Runnable() {@Overridepublic void run() {pipeline.addLast(new ServerBootstrapAcceptor(ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));}});}});

对于 ch.eventLoop().execute() 这行提交任务的代码 ch.eventLoop() 获取的是 NioEventLoop
而 NioEventLoop.execute() 执行的是其父类 SingleThreadEventExecutor 实现的 execute 方法

@Overridepublic void execute(Runnable task) {if (task == null) {throw new NullPointerException("task");}boolean inEventLoop = inEventLoop();addTask(task);if (!inEventLoop) {startThread();if (isShutdown()) {boolean reject = false;try {if (removeTask(task)) {reject = true;}} catch (UnsupportedOperationException e) {// The task queue does not support removal so the best thing we can do is to just move on and// hope we will be able to pick-up the task before its completely terminated.// In worst case we will log on termination.}if (reject) {reject();}}}if (!addTaskWakesUp && wakesUpForTask(task)) {wakeup(inEventLoop);}}

这里核心的两个方法：

addTask(task);
startThread();
1.先看 addTask(task);
    protected void addTask(Runnable task) {if (task == null) {throw new NullPointerException("task");}if (!offerTask(task)) {reject(task);}}final boolean offerTask(Runnable task) {if (isShutdown()) {reject();}return taskQueue.offer(task);}

在这里插入图片描述
在这里插入图片描述
通过断点跟踪的方式可知 public void initChannel(final Channel ch) 就是 initAndRegister() 方法中,一开始通过 channel = channelFactory.newChannel(); 初始化的 NioServerSocketChannel

2.再看 startThread(); 方法
    private void startThread() {if (state == ST_NOT_STARTED) {if (STATE_UPDATER.compareAndSet(this, ST_NOT_STARTED, ST_STARTED)) {try {doStartThread();} catch (Throwable cause) {STATE_UPDATER.set(this, ST_NOT_STARTED);PlatformDependent.throwException(cause);}}}}

直接看其核心逻辑 doStartThread()

 private void doStartThread() {assert thread == null;executor.execute(new Runnable() {@Overridepublic void run() {thread = Thread.currentThread();if (interrupted) {thread.interrupt();}boolean success = false;updateLastExecutionTime();try {SingleThreadEventExecutor.this.run();success = true;} catch (Throwable t) {logger.warn("Unexpected exception from an event executor: ", t);} finally {for (;;) {int oldState = state;if (oldState >= ST_SHUTTING_DOWN || STATE_UPDATER.compareAndSet(SingleThreadEventExecutor.this, oldState, ST_SHUTTING_DOWN)) {break;}}// Check if confirmShutdown() was called at the end of the loop.if (success && gracefulShutdownStartTime == 0) {if (logger.isErrorEnabled()) {logger.error("Buggy " + EventExecutor.class.getSimpleName() + " implementation; " +SingleThreadEventExecutor.class.getSimpleName() + ".confirmShutdown() must " +"be called before run() implementation terminates.");}}try {// Run all remaining tasks and shutdown hooks.for (;;) {if (confirmShutdown()) {break;}}} finally {try {cleanup();} finally {// Lets remove all FastThreadLocals for the Thread as we are about to terminate and notify// the future. The user may block on the future and once it unblocks the JVM may terminate// and start unloading classes.// See https://github.com/netty/netty/issues/6596.FastThreadLocal.removeAll();STATE_UPDATER.set(SingleThreadEventExecutor.this, ST_TERMINATED);threadLock.release();if (!taskQueue.isEmpty()) {if (logger.isWarnEnabled()) {logger.warn("An event executor terminated with " +"non-empty task queue (" + taskQueue.size() + ')');}}terminationFuture.setSuccess(null);}}}}});}

这里最核心的逻辑为：SingleThreadEventExecutor.this.run(); 跟进到实现方法中，很显然这里是 NioEventLoop

在这里插入图片描述
NioEventLoop run() 源码如下

@Overrideprotected void run() {for (;;) {try {try {switch (selectStrategy.calculateStrategy(selectNowSupplier, hasTasks())) {case SelectStrategy.CONTINUE:continue;case SelectStrategy.BUSY_WAIT:// fall-through to SELECT since the busy-wait is not supported with NIOcase SelectStrategy.SELECT:select(wakenUp.getAndSet(false));// 'wakenUp.compareAndSet(false, true)' is always evaluated// before calling 'selector.wakeup()' to reduce the wake-up// overhead. (Selector.wakeup() is an expensive operation.)//// However, there is a race condition in this approach.// The race condition is triggered when 'wakenUp' is set to// true too early.//// 'wakenUp' is set to true too early if:// 1) Selector is waken up between 'wakenUp.set(false)' and//    'selector.select(...)'. (BAD)// 2) Selector is waken up between 'selector.select(...)' and//    'if (wakenUp.get()) { ... }'. (OK)//// In the first case, 'wakenUp' is set to true and the// following 'selector.select(...)' will wake up immediately.// Until 'wakenUp' is set to false again in the next round,// 'wakenUp.compareAndSet(false, true)' will fail, and therefore// any attempt to wake up the Selector will fail, too, causing// the following 'selector.select(...)' call to block// unnecessarily.//// To fix this problem, we wake up the selector again if wakenUp// is true immediately after selector.select(...).// It is inefficient in that it wakes up the selector for both// the first case (BAD - wake-up required) and the second case// (OK - no wake-up required).if (wakenUp.get()) {selector.wakeup();}// fall throughdefault:}} catch (IOException e) {// If we receive an IOException here its because the Selector is messed up. Let's rebuild// the selector and retry. https://github.com/netty/netty/issues/8566rebuildSelector0();handleLoopException(e);continue;}cancelledKeys = 0;needsToSelectAgain = false;final int ioRatio = this.ioRatio;if (ioRatio == 100) {try {processSelectedKeys();} finally {// Ensure we always run tasks.runAllTasks();}} else {final long ioStartTime = System.nanoTime();try {processSelectedKeys();} finally {// Ensure we always run tasks.final long ioTime = System.nanoTime() - ioStartTime;runAllTasks(ioTime * (100 - ioRatio) / ioRatio);}}} catch (Throwable t) {handleLoopException(t);}// Always handle shutdown even if the loop processing threw an exception.try {if (isShuttingDown()) {closeAll();if (confirmShutdown()) {return;}}} catch (Throwable t) {handleLoopException(t);}}}

这里搞了个死循环来执行逻辑
在这里插入图片描述
我们这里重点关注 select(wakenUp.getAndSet(false));

case SelectStrategy.SELECT:select(wakenUp.getAndSet(false));

 private void select(boolean oldWakenUp) throws IOException {Selector selector = this.selector;try {int selectCnt = 0;long currentTimeNanos = System.nanoTime();long selectDeadLineNanos = currentTimeNanos + delayNanos(currentTimeNanos);for (;;) {long timeoutMillis = (selectDeadLineNanos - currentTimeNanos + 500000L) / 1000000L;if (timeoutMillis <= 0) {if (selectCnt == 0) {selector.selectNow();selectCnt = 1;}break;}// If a task was submitted when wakenUp value was true, the task didn't get a chance to call// Selector#wakeup. So we need to check task queue again before executing select operation.// If we don't, the task might be pended until select operation was timed out.// It might be pended until idle timeout if IdleStateHandler existed in pipeline.if (hasTasks() && wakenUp.compareAndSet(false, true)) {selector.selectNow();selectCnt = 1;break;}int selectedKeys = selector.select(timeoutMillis);selectCnt ++;if (selectedKeys != 0 || oldWakenUp || wakenUp.get() || hasTasks() || hasScheduledTasks()) {// - Selected something,// - waken up by user, or// - the task queue has a pending task.// - a scheduled task is ready for processingbreak;}if (Thread.interrupted()) {// Thread was interrupted so reset selected keys and break so we not run into a busy loop.// As this is most likely a bug in the handler of the user or it's client library we will// also log it.//// See https://github.com/netty/netty/issues/2426if (logger.isDebugEnabled()) {logger.debug("Selector.select() returned prematurely because " +"Thread.currentThread().interrupt() was called. Use " +"NioEventLoop.shutdownGracefully() to shutdown the NioEventLoop.");}selectCnt = 1;break;}long time = System.nanoTime();if (time - TimeUnit.MILLISECONDS.toNanos(timeoutMillis) >= currentTimeNanos) {// timeoutMillis elapsed without anything selected.selectCnt = 1;} else if (SELECTOR_AUTO_REBUILD_THRESHOLD > 0 &&selectCnt >= SELECTOR_AUTO_REBUILD_THRESHOLD) {// The code exists in an extra method to ensure the method is not too big to inline as this// branch is not very likely to get hit very frequently.selector = selectRebuildSelector(selectCnt);selectCnt = 1;break;}currentTimeNanos = time;}if (selectCnt > MIN_PREMATURE_SELECTOR_RETURNS) {if (logger.isDebugEnabled()) {logger.debug("Selector.select() returned prematurely {} times in a row for Selector {}.",selectCnt - 1, selector);}}} catch (CancelledKeyException e) {if (logger.isDebugEnabled()) {logger.debug(CancelledKeyException.class.getSimpleName() + " raised by a Selector {} - JDK bug?",selector, e);}// Harmless exception - log anyway}}

在该 select() 方法中同样使用了 for (;;) 死循环进行逻辑执行。不同于 run() 方法的是循环没有跳出而 select() 是有 break 跳出条件的。

同样的我们看关键逻辑：

  int selectedKeys = selector.select(timeoutMillis);

这里就是 Nio 的代码，进行了一个超时阻塞操作，获取 selectedKeys 或者直到超时。

如果获取到了事件则跳出该循环

       if (selectedKeys != 0 || oldWakenUp || wakenUp.get() || hasTasks() || hasScheduledTasks()) {// - Selected something,// - waken up by user, or// - the task queue has a pending task.// - a scheduled task is ready for processingbreak;}

简单串一下目前的逻辑：
1.在 run() 方法中 死循环 for(;;) 执行 首先进行了 switch select()

     case SelectStrategy.SELECT:select(wakenUp.getAndSet(false));

2.在 switch select() 同样进行了 for(;;) 循环，正常流程会 超时阻塞等待 select 事件 selector.select(timeoutMillis)，如果获取到事件则跳出循环 。一般情况该循环会等待事件获取，或者直到超时才进行跳出，返回 run() 方法的主循环逻辑进行后面方法的执行。
目前为止，这里是大循环套了一个小循环，进行事件的监听选择。

跳出 switch select() 循环后会执行到后面的核心逻辑

if (ioRatio == 100) {try {processSelectedKeys();} finally {// Ensure we always run tasks.runAllTasks();}
} else {final long ioStartTime = System.nanoTime();try {processSelectedKeys();} finally {// Ensure we always run tasks.final long ioTime = System.nanoTime() - ioStartTime;runAllTasks(ioTime * (100 - ioRatio) / ioRatio);}
}

可以看到无论如何都会走到两个主逻辑中，这里我们重点看下这两个核心逻辑

processSelectedKeys();
runAllTasks();

首先处理被选择 keys 方法 processSelectedKeys()

private void processSelectedKeys() {if (selectedKeys != null) {processSelectedKeysOptimized();} else {processSelectedKeysPlain(selector.selectedKeys());}
}

通过 debug 断点可以看到在启动 NettyServer 的时候 selectedKeys 不为空 但 size = 0
所以会进入方法 processSelectedKeysOptimized()

我们两个方法都过一下：

private void processSelectedKeysOptimized() {for (int i = 0; i < selectedKeys.size; ++i) {final SelectionKey k = selectedKeys.keys[i];// null out entry in the array to allow to have it GC'ed once the Channel close// See https://github.com/netty/netty/issues/2363selectedKeys.keys[i] = null;final Object a = k.attachment();if (a instanceof AbstractNioChannel) {processSelectedKey(k, (AbstractNioChannel) a);} else {@SuppressWarnings("unchecked")NioTask<SelectableChannel> task = (NioTask<SelectableChannel>) a;processSelectedKey(k, task);}if (needsToSelectAgain) {// null out entries in the array to allow to have it GC'ed once the Channel close// See https://github.com/netty/netty/issues/2363selectedKeys.reset(i + 1);selectAgain();i = -1;}}
}

private void processSelectedKeysPlain(Set<SelectionKey> selectedKeys) {// check if the set is empty and if so just return to not create garbage by// creating a new Iterator every time even if there is nothing to process.// See https://github.com/netty/netty/issues/597if (selectedKeys.isEmpty()) {return;}Iterator<SelectionKey> i = selectedKeys.iterator();for (;;) {final SelectionKey k = i.next();final Object a = k.attachment();i.remove();if (a instanceof AbstractNioChannel) {processSelectedKey(k, (AbstractNioChannel) a);} else {@SuppressWarnings("unchecked")NioTask<SelectableChannel> task = (NioTask<SelectableChannel>) a;processSelectedKey(k, task);}if (!i.hasNext()) {break;}if (needsToSelectAgain) {selectAgain();selectedKeys = selector.selectedKeys();// Create the iterator again to avoid ConcurrentModificationExceptionif (selectedKeys.isEmpty()) {break;} else {i = selectedKeys.iterator();}}}
}

可以看到其实大同小异，最终都会走到 processSelectedKey() 这样一个方法中，方法有两个实现 ：

  1. processSelectedKey(SelectionKey k, AbstractNioChannel ch)
  2. processSelectedKey(SelectionKey k, NioTask<SelectableChannel> task)
private void processSelectedKey(SelectionKey k, AbstractNioChannel ch) {final AbstractNioChannel.NioUnsafe unsafe = ch.unsafe();if (!k.isValid()) {final EventLoop eventLoop;try {eventLoop = ch.eventLoop();} catch (Throwable ignored) {// If the channel implementation throws an exception because there is no event loop, we ignore this// because we are only trying to determine if ch is registered to this event loop and thus has authority// to close ch.return;}// Only close ch if ch is still registered to this EventLoop. ch could have deregistered from the event loop// and thus the SelectionKey could be cancelled as part of the deregistration process, but the channel is// still healthy and should not be closed.// See https://github.com/netty/netty/issues/5125if (eventLoop != this || eventLoop == null) {return;}// close the channel if the key is not valid anymoreunsafe.close(unsafe.voidPromise());return;}try {int readyOps = k.readyOps();// We first need to call finishConnect() before try to trigger a read(...) or write(...) as otherwise// the NIO JDK channel implementation may throw a NotYetConnectedException.if ((readyOps & SelectionKey.OP_CONNECT) != 0) {// remove OP_CONNECT as otherwise Selector.select(..) will always return without blocking// See https://github.com/netty/netty/issues/924int ops = k.interestOps();ops &= ~SelectionKey.OP_CONNECT;k.interestOps(ops);unsafe.finishConnect();}// Process OP_WRITE first as we may be able to write some queued buffers and so free memory.if ((readyOps & SelectionKey.OP_WRITE) != 0) {// Call forceFlush which will also take care of clear the OP_WRITE once there is nothing left to writech.unsafe().forceFlush();}// Also check for readOps of 0 to workaround possible JDK bug which may otherwise lead// to a spin loopif ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) {unsafe.read();}} catch (CancelledKeyException ignored) {unsafe.close(unsafe.voidPromise());}
}
private static void processSelectedKey(SelectionKey k, NioTask<SelectableChannel> task) {int state = 0;try {task.channelReady(k.channel(), k);state = 1;} catch (Exception e) {k.cancel();invokeChannelUnregistered(task, k, e);state = 2;} finally {switch (state) {case 0:k.cancel();invokeChannelUnregistered(task, k, null);break;case 1:if (!k.isValid()) { // Cancelled by channelReady()invokeChannelUnregistered(task, k, null);}break;}}
}

这里我们主要看方法 1 。可以看到该方法主要逻辑是通过位与操作来判断是否是对应的事件从而进行相应的操作

if ((readyOps & SelectionKey.OP_CONNECT) != 0)
if ((readyOps & SelectionKey.OP_WRITE) != 0)
if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0)

最终调用 unsafe 的几个方法 final AbstractNioChannel.NioUnsafe unsafe = ch.unsafe();

	unsafe.finishConnect();ch.unsafe().forceFlush();unsafe.read();public interface NioUnsafe extends Unsafe {/*** Return underlying {@link SelectableChannel}*/SelectableChannel ch();/*** Finish connect*/void finishConnect();/*** Read from underlying {@link SelectableChannel}*/void read();void forceFlush();}

这块首先要记住几个 unsafe 内部类

protected abstract class AbstractNioUnsafe extends AbstractUnsafe implements NioUnsafe
protected class NioByteUnsafe extends AbstractNioUnsafe
private final class NioMessageUnsafe extends AbstractNioUnsafe

AbstractNioUnsafe 为 AbstractChannel 内部类
NioByteUnsafe 为 AbstractNioMessageChannel 内部类
NioMessageUnsafe 为 AbstractNioMessageChannel 内部类

这几个方法还是比较重要的，这里先有个印象，暂时按下不表，我们继续走下面的流程

到这里 processSelectedKeys(); 的流程就走完了，这里就形成了下图循环的前两步
在这里插入图片描述
NioEventLoop 为 Netty 提供了这样的 run 方法循环，该死循环核心三步为：

  1. select(wakenUp.getAndSet(false));
  2. processSelectedKeys();
  3. runAllTasks();

第三步 runAllTasks();

从名字上看，就可以理解到 是执行任务了。

  protected boolean runAllTasks() {assert inEventLoop();boolean fetchedAll;boolean ranAtLeastOne = false;do {fetchedAll = fetchFromScheduledTaskQueue();if (runAllTasksFrom(taskQueue)) {ranAtLeastOne = true;}} while (!fetchedAll); // keep on processing until we fetched all scheduled tasks.if (ranAtLeastOne) {lastExecutionTime = ScheduledFutureTask.nanoTime();}afterRunningAllTasks();return ranAtLeastOne;}

这里我们主要看 runAllTasksFrom(taskQueue)

   protected final boolean runAllTasksFrom(Queue<Runnable> taskQueue) {Runnable task = pollTaskFrom(taskQueue);if (task == null) {return false;}for (;;) {safeExecute(task);task = pollTaskFrom(taskQueue);if (task == null) {return true;}}}

这里从之前 NioEventLoop 中 的 taskQueue 取出任务执行

   protected static Runnable pollTaskFrom(Queue<Runnable> taskQueue) {for (;;) {Runnable task = taskQueue.poll();if (task == WAKEUP_TASK) {continue;}return task;}}

    protected static void safeExecute(Runnable task) {try {task.run();} catch (Throwable t) {logger.warn("A task raised an exception. Task: {}", task, t);}}

这个时候 taskQueue 是没有任务的，何时有任务我们放到后面的文章进行讲解。

到这里 startThread(); 的主线逻辑就过完了。

总结

本篇作为中篇吧，行文实在有点长了，简单做个总结。
本文主要介绍了 Netty 自定义的 Executor 中的执行逻辑，也是 Netty 处理任务的关键逻辑。

核心类为：SingleThreadEventExecutor
核心方法 ：

// 重写了提交任务方法
public void execute(Runnable task)
protected void addTask(Runnable task)
private void startThread()
private void doStartThread()
protected abstract void run();
protected boolean runAllTasks()

以及 NioEventLoop 中对 SingleThreadEventExecutor run() 抽象方法的实现

protected void run()
private void processSelectedKeys()
private void select(boolean oldWakenUp)

其中最为重要的是 doStartThread() 方法中调用的 NioEventLoop 实现的 run() 方法

SingleThreadEventExecutor.this.run();

run() 方法中进行了 循环三部曲

  1. select 超时阻塞事件选择
  2. processSelectedKeys unsafe 事件处理
  3. runAllTasks 执行 taskQueue 中所有任务

在这里插入图片描述
最后的最后，其实还有很重要的一点不知道大家注意到了没有，这里我在放上源码：

        p.addLast(new ChannelInitializer<Channel>() {@Overridepublic void initChannel(final Channel ch) throws Exception {final ChannelPipeline pipeline = ch.pipeline();ChannelHandler handler = config.handler();if (handler != null) {pipeline.addLast(handler);}ch.eventLoop().execute(new Runnable() {@Overridepublic void run() {pipeline.addLast(new ServerBootstrapAcceptor(ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));}});}});

其实在 init 这里 ch.eventLoop().execute 并没有真正的执行，这里只是进行了重写声明而已。而在后文的 register 中会有直接的执行。

经过上文的介绍相信大家对上图也有了具体的理解。下篇文章将开启 register 之旅。感谢可以看到这里，希望本文对你有所帮助。

我是 dying 搁浅 ，我始终期待与你的相遇。无论你是否期待，潮涨潮落，我仅且就在这里…

我们下期再见~
在这里插入图片描述

这篇关于【对话写 Netty 代码的同学，你真的懂 Netty 了吗？（三中）】initAndRegister() 之 init() 对不起！！我柜子动了…我不学了的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/329719。

相关文章

利用Python调试串口的示例代码

利用Python调试串口的示例代码

《利用Python调试串口的示例代码》在嵌入式开发、物联网设备调试过程中,串口通信是最基础的调试手段本文将带你用Python+ttkbootstrap打造一款高颜值、多功能的串口调试助手,需要的可以了... 目录概述：为什么需要专业的串口调试工具项目架构设计1.1 技术栈选型1.2 关键类说明1.3 线程模
阅读更多...
Python Transformers库(NLP处理库)案例代码讲解

Python Transformers库(NLP处理库)案例代码讲解

《PythonTransformers库(NLP处理库)案例代码讲解》本文介绍transformers库的全面讲解,包含基础知识、高级用法、案例代码及学习路径,内容经过组织,适合不同阶段的学习者,对... 目录一、基础知识1. Transformers 库简介2. 安装与环境配置3. 快速上手示例二、核心模
阅读更多...
Java的栈与队列实现代码解析

Java的栈与队列实现代码解析

《Java的栈与队列实现代码解析》栈是常见的线性数据结构,栈的特点是以先进后出的形式,后进先出,先进后出,分为栈底和栈顶,栈应用于内存的分配,表达式求值,存储临时的数据和方法的调用等,本文给大家介绍J... 目录栈的概念（Stack）栈的实现代码队列（Queue）模拟实现队列(双链表实现)循环队列（循环数组
阅读更多...
一文带你搞懂Python中__init__.py到底是什么

一文带你搞懂Python中__init__.py到底是什么

《一文带你搞懂Python中__init__.py到底是什么》朋友们,今天我们来聊聊Python里一个低调却至关重要的文件——__init__.py,有些人可能听说过它是“包的标志”,也有人觉得它“没... 目录先搞懂 python 模块（module）Python 包（package）是啥？那么 __in
阅读更多...
Python中__init__方法使用的深度解析

Python中__init__方法使用的深度解析

《Python中__init__方法使用的深度解析》在Python的面向对象编程（OOP）体系中,__init__方法如同建造房屋时的奠基仪式——它定义了对象诞生时的初始状态,下面我们就来深入了解下_... 目录一、__init__的基因图谱二、初始化过程的魔法时刻继承链中的初始化顺序self参数的奥秘默认
阅读更多...
使用Java将DOCX文档解析为Markdown文档的代码实现

使用Java将DOCX文档解析为Markdown文档的代码实现

《使用Java将DOCX文档解析为Markdown文档的代码实现》在现代文档处理中,Markdown（MD）因其简洁的语法和良好的可读性,逐渐成为开发者、技术写作者和内容创作者的首选格式,然而,许多文... 目录引言1. 工具和库介绍2. 安装依赖库3. 使用Apache POI解析DOCX文档4. 将解析
阅读更多...
C++使用printf语句实现进制转换的示例代码

C++使用printf语句实现进制转换的示例代码

《C++使用printf语句实现进制转换的示例代码》在C语言中,printf函数可以直接实现部分进制转换功能,通过格式说明符（formatspecifier）快速输出不同进制的数值,下面给大家分享C+... 目录一、printf 原生支持的进制转换1. 十进制、八进制、十六进制转换2. 显示进制前缀3. 指
阅读更多...
使用Python实现全能手机虚拟键盘的示例代码

使用Python实现全能手机虚拟键盘的示例代码

《使用Python实现全能手机虚拟键盘的示例代码》在数字化办公时代,你是否遇到过这样的场景：会议室投影电脑突然键盘失灵、躺在沙发上想远程控制书房电脑、或者需要给长辈远程协助操作？今天我要分享的Pyth... 目录一、项目概述：不止于键盘的远程控制方案1.1 创新价值1.2 技术栈全景二、需求实现步骤一、需求
阅读更多...
Java中Date、LocalDate、LocalDateTime、LocalTime、时间戳之间的相互转换代码

Java中Date、LocalDate、LocalDateTime、LocalTime、时间戳之间的相互转换代码

《Java中Date、LocalDate、LocalDateTime、LocalTime、时间戳之间的相互转换代码》：本文主要介绍Java中日期时间转换的多种方法,包括将Date转换为LocalD... 目录一、Date转LocalDateTime二、Date转LocalDate三、LocalDateTim
阅读更多...
jupyter代码块没有运行图标的解决方案

jupyter代码块没有运行图标的解决方案

《jupyter代码块没有运行图标的解决方案》：本文主要介绍jupyter代码块没有运行图标的解决方案,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录jupyter代码块没有运行图标的解决1.找到Jupyter notebook的系统配置文件2.这时候一般会搜索到
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2