【Netty 专栏】Netty源码分析之服务启动

生产环境 java.util.concurrent.RejectedExecutionException: event executor terminated 错误分析 今天运维在执行线上功能时发现服务异常,跟进之后发现Redis出现问题,如下: [ERROR] [2022-05-26 00:05:01.518] [c.q.d.utils.DataAccessSampleRedisUtil:326][Thread-154] 服务名称:ivdg-data-access-service--> 查询缓存数据出错:Unknown redis exception; nested exception is java.util.concurrent.RejectedExecu. 阅读详情

点击上方“芋道源码”,选择“置顶公众号”

技术文章第一时间送达!

源码精品专栏

 

本文主要分析Netty服务端的启动过程。

Netty是基于Nio实现的,所以也离不开selector、serverSocketChannel、socketChannel和selectKey等,只不过Netty把这些实现都封装在了底层。

从示例可以看出,一切从ServerBootstrap开始。

ServerBootstrap实例中需要两个NioEventLoopGroup实例,按照职责划分成boss和work,有着不同的分工:
1、boss负责请求的accept
2、work负责请求的read、write

NioEventLoopGroup

NioEventLoopGroup主要管理eventLoop的生命周期。
eventLoop是什么?姑且把它看成是内部的一个处理线程,数量默认是处理器个数的两倍。

img

NioEventLoopGroup构造方法:

public NioEventLoopGroup() {  
   this(0);  
}  
public NioEventLoopGroup(int nThreads) {  
   this(nThreads, null);
}  
public NioEventLoopGroup(int nThreads, ThreadFactory threadFactory) {  
   this(nThreads, threadFactory, SelectorProvider.provider());  
}  
public NioEventLoopGroup(  
           int nThreads, ThreadFactory threadFactory, final SelectorProvider selectorProvider) {  
   super(nThreads, threadFactory, selectorProvider);  
}  

MultithreadEventLoopGroup是NioEventLoopGroup的父类,构造方法:

protected MultithreadEventLoopGroup(int nThreads, ThreadFactory threadFactory, Object... args) {  
   super(nThreads == 0? DEFAULT_EVENT_LOOP_THREADS : nThreads, threadFactory, args);  
}  

其中 DEFAULT_EVENT_LOOP_THREADS 为处理器数量的两倍。

MultithreadEventExecutorGroup是核心,管理eventLoop的生命周期,先看看其中几个变量。
1、children:EventExecutor数组,保存eventLoop。
2、chooser:从children中选取一个eventLoop的策略。

构造方法:

protected MultithreadEventExecutorGroup(int nThreads, ThreadFactory threadFactory, Object... args) {
   if (nThreads <= 0) {
       throw new IllegalArgumentException(String.format("nThreads: %d (expected: > 0)", nThreads));
   }
   if (threadFactory == null) {
       threadFactory = newDefaultThreadFactory();
   }
   children = new SingleThreadEventExecutor[nThreads];
   if (isPowerOfTwo(children.length)) {
       chooser = new PowerOfTwoEventExecutorChooser();
   } else {
       chooser = new GenericEventExecutorChooser();
   }
   for (int i = 0; i < nThreads; i ++) {
       boolean success = false;
       try {
           children[i] = newChild(threadFactory, args);
           success = true;
       } catch (Exception e) {
           // TODO: Think about if this is a good exception type
           throw new IllegalStateException("failed to create a child event loop", e);
       } finally {
           if (!success) {
               for (int j = 0; j < i; j ++) {
                   children[j].shutdownGracefully();
               }
               for (int j = 0; j < i; j ++) {
                   EventExecutor e = children[j];
                   try {
                       while (!e.isTerminated()) {
                           e.awaitTermination(Integer.MAX_VALUE, TimeUnit.SECONDS);
                       }
                   } catch (InterruptedException interrupted) {
                       Thread.currentThread().interrupt();
                       break;
                   }
               }
           }
       }
   }
   final FutureListener<Object> terminationListener = new FutureListener<Object>() {
       @Override
       public void operationComplete(Future<Object> future) throws Exception {
           if (terminatedChildren.incrementAndGet() == children.length) {
               terminationFuture.setSuccess(null);
           }
       }
   };
   for (EventExecutor e: children) {
       e.terminationFuture().addListener(terminationListener);
   }
}
protected EventExecutor newChild(  
           ThreadFactory threadFactory, Object... args) throws Exception {  
     return new NioEventLoop(this, threadFactory, (SelectorProvider) args[0]);  
}  

1、根据数组的大小,采用不同策略初始化chooser,如果大小为2的幂次方,则采用PowerOfTwoEventExecutorChooser,否则使用GenericEventExecutorChooser。

其中判断一个数是否是2的幂次方的方法,觉得很赞。

private static boolean isPowerOfTwo(int val) {
     return (val & -val) == val;
}

2、newChild方法重载,初始化EventExecutor时,实际执行的是NioEventLoopGroup中的newChild方法,所以children元素的实际类型为NioEventLoop。

接下去看看NioEventLoop类。

NioEventLoop

每个eventLoop会维护一个selector和taskQueue,负责处理客户端请求和内部任务,如ServerSocketChannel注册和ServerSocket绑定等。

img

NioEventLoop构造方法:

 NioEventLoop(NioEventLoopGroup parent, ThreadFactory threadFactory, SelectorProvider selectorProvider) {  
     super(parent, threadFactory, false);  
     if (selectorProvider == null) {  
         throw new NullPointerException("selectorProvider");  
     }  
     provider = selectorProvider;  
     selector = openSelector();  
}  

当看到 selector = openSelector() 时,有没有觉得亲切了许多,这里先不管 selector,看看SingleThreadEventLoop类。

SingleThreadEventLoop是NioEventLoop的父类,构造方法:

protected SingleThreadEventLoop(EventLoopGroup parent, ThreadFactory threadFactory, boolean addTaskWakesUp) {
   super(parent, threadFactory, addTaskWakesUp);
}

啥事都没做…

继续看SingleThreadEventLoop的父类SingleThreadEventExecutor

从类名上可以看出,这是一个只有一个线程的线程池, 先看看其中的几个变量:
1、state:线程池当前的状态
2、taskQueue:存放任务的队列
3、thread:线程池维护的唯一线程
4、scheduledTaskQueue:定义在其父类AbstractScheduledEventExecutor中,用以保存延迟执行的任务。
…
构造方法:

protected SingleThreadEventExecutor(EventExecutorGroup parent, ThreadFactory threadFactory, boolean addTaskWakesUp) {
   if (threadFactory == null) {
       throw new NullPointerException("threadFactory");
   }
   this.parent = parent;
   this.addTaskWakesUp = addTaskWakesUp;
   thread = threadFactory.newThread(new Runnable() {
       @Override
       public void run() {
           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_UPDATER.get(SingleThreadEventExecutor.this);
                   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) {
                   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 {
                       STATE_UPDATER.set(SingleThreadEventExecutor.this, ST_TERMINATED);
                       threadLock.release();
                       if (!taskQueue.isEmpty()) {
                           logger.warn(
                                   "An event executor terminated with " +
                                   "non-empty task queue (" + taskQueue.size() + ')');
                       }
                       terminationFuture.setSuccess(null);
                   }
               }
           }
       }
   });
   threadProperties = new DefaultThreadProperties(thread);
   taskQueue = newTaskQueue();
}

代码很长,内容很简单:
1、初始化一个线程,并在线程内部执行NioEventLoop类的run方法,当然这个线程不会立刻执行。
2、使用LinkedBlockingQueue类初始化taskQueue。

到目前为止,相关的处理线程已经初始化完成。

ServerBootstrap

通过serverBootstrap.bind(port)启动服务,过程如下:

/**
* Create a new {@link Channel} and bind it.
*/
public ChannelFuture bind() {
   validate();
   SocketAddress localAddress = this.localAddress;
   if (localAddress == null) {
      throw new IllegalStateException("localAddress not set");
   }
   return doBind(localAddress);
}
img

doBind实现如下

private ChannelFuture doBind(final SocketAddress localAddress) {
   final ChannelFuture regFuture = initAndRegister();
   final Channel channel = regFuture.channel();
   if (regFuture.cause() != null) {
       return regFuture;
   }
   if (regFuture.isDone()) {
       // At this point we know that the registration was complete and successful.
       ChannelPromise promise = channel.newPromise();
       doBind0(regFuture, channel, localAddress, promise);
       return promise;
   } else {
       // Registration future is almost always fulfilled already, but just in case it's not.
       final PendingRegistrationPromise promise = new PendingRegistrationPromise(channel);
       regFuture.addListener(new ChannelFutureListener() {
           @Override
           public void operationComplete(ChannelFuture future) throws Exception {
               Throwable cause = future.cause();
               if (cause != null) {
                   // Registration on the EventLoop failed so fail the ChannelPromise directly to not cause an
                   // IllegalStateException once we try to access the EventLoop of the Channel.
                   promise.setFailure(cause);
               } else {
                   // Registration was successful, so set the correct executor to use.
                   // See https://github.com/netty/netty/issues/2586
                   promise.executor = channel.eventLoop();
               }
               doBind0(regFuture, channel, localAddress, promise);
           }
       });
       return promise;
   }
}

1、方法initAndRegister返回一个ChannelFuture实例regFuture,通过regFuture可以判断initAndRegister执行结果。
2、如果regFuture.isDone()为true,说明initAndRegister已经执行完,则直接执行doBind0进行socket绑定。
3、否则regFuture添加一个ChannelFutureListener监听,当initAndRegister执行完成时,调用operationComplete方法并执行doBind0进行socket绑定。

所以只有当initAndRegister操作结束之后才能进行bind操作。

initAndRegister实现

final ChannelFuture initAndRegister() {
   final Channel channel = channelFactory().newChannel();
   try {
       init(channel);
   } catch (Throwable t) {
       channel.unsafe().closeForcibly();
       // as the Channel is not registered yet we need to force the usage of the GlobalEventExecutor
       return new DefaultChannelPromise(channel, GlobalEventExecutor.INSTANCE).setFailure(t);
   }
   ChannelFuture regFuture = group().register(channel);
   if (regFuture.cause() != null) {
       if (channel.isRegistered()) {
           channel.close();
       } else {
           channel.unsafe().closeForcibly();
       }
   }
   return regFuture;
}

1、负责创建服务端的NioServerSocketChannel实例
2、为NioServerSocketChannel的pipeline添加handler
3、注册NioServerSocketChannel到selector

大部分的过程和NIO中类似。

NioServerSocketChannel

对Nio的ServerSocketChannel和SelectionKey进行了封装。

构造方法:

public NioServerSocketChannel() {
   this(newSocket(DEFAULT_SELECTOR_PROVIDER));
}
private static ServerSocketChannel newSocket(SelectorProvider provider) {
   try {
       return provider.openServerSocketChannel();
   } catch (IOException e) {
       throw new ChannelException(
               "Failed to open a server socket.", e);
   }
}
public NioServerSocketChannel(ServerSocketChannel channel) {
   super(null, channel, SelectionKey.OP_ACCEPT);
   config = new NioServerSocketChannelConfig(this, javaChannel().socket());
}

1、方法newSocket利用 provider.openServerSocketChannel() 生成Nio中的ServerSocketChannel对象。
2、设置SelectionKey.OP_ACCEPT事件。

AbstractNioMessageChannel构造方法

protected  AbstractNioMessageChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
   super(parent, ch, readInterestOp);
}

啥也没做…

AbstractNioChannel构造方法

protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
   super(parent);
   this.ch = ch;
   this.readInterestOp = readInterestOp;
   try {
       ch.configureBlocking(false);
   } catch (IOException e) {
       try {
           ch.close();
       } catch (IOException e2) {
           if (logger.isWarnEnabled()) {
               logger.warn(
                       "Failed to close a partially initialized socket.", e2);
           }
       }
       throw new ChannelException("Failed to enter non-blocking mode.", e);
   }
}

设置当前ServerSocketChannel为非阻塞通道。

AbstractChannel构造方法

protected AbstractChannel(Channel parent) {
   this.parent = parent;
   unsafe = newUnsafe();
   pipeline = new DefaultChannelPipeline(this);
}

1、初始化unsafe,这里的Unsafe并非是jdk中底层Unsafe类,用来负责底层的connect、register、read和write等操作。
2、初始化pipeline,每个Channel都有自己的pipeline,当有请求事件发生时,pipeline负责调用相应的hander进行处理。

unsafe和pipeline的具体实现原理会在后续进行分析。


回到ServerBootstrap的init(Channel channel)方法,添加handler到channel的pipeline中。

void init(Channel channel) throws Exception {
   final Map<ChannelOption<?>, Object> options = options();
   synchronized (options) {
       channel.config().setOptions(options);
   }
   final Map<AttributeKey<?>, Object> attrs = attrs();
   synchronized (attrs) {
       for (Entry<AttributeKey<?>, Object> e: attrs.entrySet()) {
           @SuppressWarnings("unchecked")
           AttributeKey<Object> key = (AttributeKey<Object>) e.getKey();
           channel.attr(key).set(e.getValue());
       }
   }
   ChannelPipeline p = channel.pipeline();
   final EventLoopGroup currentChildGroup = childGroup;
   final ChannelHandler currentChildHandler = childHandler;
   final Entry<ChannelOption<?>, Object>[] currentChildOptions;
   final Entry<AttributeKey<?>, Object>[] currentChildAttrs;
   synchronized (childOptions) {
       currentChildOptions = childOptions.entrySet().toArray(newOptionArray(childOptions.size()));
   }
   synchronized (childAttrs) {
       currentChildAttrs = childAttrs.entrySet().toArray(newAttrArray(childAttrs.size()));
   }
   p.addLast(new ChannelInitializer<Channel>() {
       @Override
       public void initChannel(Channel ch) throws Exception {
           ChannelPipeline pipeline = ch.pipeline();
           ChannelHandler handler = handler();
           if (handler != null) {
               pipeline.addLast(handler);
           }
           pipeline.addLast(new ServerBootstrapAcceptor(
                   currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
       }
   });
}

1、设置channel的options和attrs。
2、在pipeline中添加一个ChannelInitializer对象。


init执行完,需要把当前channel注册到EventLoopGroup。
其实最终目的是为了实现Nio中把ServerSocket注册到selector上,这样就可以实现client请求的监听了。看看Netty中是如何实现的:

public ChannelFuture register(Channel channel, ChannelPromise promise) {
   return next().register(channel, promise);
}
public EventLoop next() {
   return (EventLoop) super.next();
}
public EventExecutor next() {
   return children[Math.abs(childIndex.getAndIncrement() % children.length)];
}

因为EventLoopGroup中维护了多个eventLoop,next方法会调用chooser策略找到下一个eventLoop,并执行eventLoop的register方法进行注册。

public ChannelFuture register(final Channel channel, final ChannelPromise promise) {
   ...
   channel.unsafe().register(this, promise);
   return promise;
}

channel.unsafe()是什么?
NioServerSocketChannel初始化时,会创建一个NioMessageUnsafe实例,用于实现底层的register、read、write等操作。

eventLoop.execute(new Runnable() {
  @Override
  public void run() {
     register0(promise);
  }
});
private void register0(ChannelPromise promise) {
   try {
       if (!ensureOpen(promise)) {
           return;
       }
       Runnable postRegisterTask = doRegister();
       registered = true;
       promise.setSuccess();
       pipeline.fireChannelRegistered();
       if (postRegisterTask != null) {
           postRegisterTask.run();
       }
       if (isActive()) {
           pipeline.fireChannelActive();
       }
   } catch (Throwable t) {
       // Close the channel directly to avoid FD leak.
       closeForcibly();
       if (!promise.tryFailure(t)) {
       }
       closeFuture.setClosed();
   }
}
public void execute(Runnable task) {
   if (task == null) {
       throw new NullPointerException("task");
   }
   boolean inEventLoop = inEventLoop();
   if (inEventLoop) {
       addTask(task);
   } else {
       startThread();
       addTask(task);
       if (isShutdown() && removeTask(task)) {
           reject();
       }
   }
   if (!addTaskWakesUp) {
       wakeup(inEventLoop);
   }
}

1、register0方法提交到eventLoop线程池中执行,这个时候会启动eventLoop中的线程。
2、方法doRegister()才是最终Nio中的注册方法,方法javaChannel()获取ServerSocketChannel。

protected Runnable doRegister() throws Exception {
   boolean selected = false;
   for (;;) {
       try {
           selectionKey = javaChannel().register(eventLoop().selector, 0, this);
           return null;
       } catch (CancelledKeyException e) {
           if (!selected) {
               // Force the Selector to select now  as the "canceled" SelectionKey may still be
               // cached and not removed because no Select.select(..) operation was called yet.
               eventLoop().selectNow();
               selected = true;
           } else {
               // We forced a select operation on the selector before but the SelectionKey is still cached
               // for whatever reason. JDK bug ?
               throw e;
           }
       }
   }
}

ServerSocketChannel注册完之后,通知pipeline执行fireChannelRegistered方法,pipeline中维护了handler链表,通过遍历链表,执行InBound类型handler的channelRegistered方法,最终执行init中添加的ChannelInitializer handler。

public final void channelRegistered(ChannelHandlerContext ctx)
       throws Exception {
   boolean removed = false;
   boolean success = false;
   try {
       initChannel((C) ctx.channel());
       ctx.pipeline().remove(this);
       removed = true;
       ctx.fireChannelRegistered();
       success = true;
   } catch (Throwable t) {
       logger.warn("Failed to initialize a channel. Closing: " + ctx.channel(), t);
   } finally {
       if (!removed) {
           ctx.pipeline().remove(this);
       }
       if (!success) {
           ctx.close();
       }
   }
}

1、initChannel方法最终把ServerBootstrapAcceptor添加到ServerSocketChannel的pipeline,负责accept客户端请求。
2、在pipeline中删除对应的handler。
3、触发fireChannelRegistered方法,可以自定义handler的channelRegistered方法。

到目前为止,ServerSocketChannel完成了初始化并注册到seletor上,启动线程执行selector.select()方法准备接受客户端请求。

细心的同学已经发现,ServerSocketChannel的socket还未绑定到指定端口,那么这一块Netty是如何实现的?
Netty把注册操作放到eventLoop中执行。

private static void doBind0(
       final ChannelFuture regFuture,
       final Channel channel,
       final SocketAddress localAddress,
       final ChannelPromise promise) {
   channel.eventLoop().execute(new Runnable() {
       @Override
       public void run() {
           if (regFuture.isSuccess()) {
               channel.bind(localAddress, promise)
.addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
           } else {
               promise.setFailure(regFuture.cause());
           }
       }
   });
}
public ChannelFuture bind(SocketAddress localAddress, ChannelPromise promise) {
   return pipeline.bind(localAddress, promise);
}
@Override
public ChannelFuture bind(SocketAddress localAddress, ChannelPromise promise) {
   return tail.bind(localAddress, promise);
}
@Override
public ChannelFuture bind(SocketAddress localAddress, ChannelPromise promise) {
   if (localAddress == null) {
       throw new NullPointerException("localAddress");
   }
   validatePromise(promise, false);
   return findContextOutbound().invokeBind(localAddress, promise);
}
private ChannelFuture invokeBind(final SocketAddress localAddress, final ChannelPromise promise) {
   EventExecutor executor = executor();
   if (executor.inEventLoop()) {
       invokeBind0(localAddress, promise);
   } else {
       executor.execute(new Runnable() {
           @Override
           public void run() {
               invokeBind0(localAddress, promise);
           }
       });
   }
   return promise;
}
private void invokeBind0(SocketAddress localAddress, ChannelPromise promise) {
   try {
       ((ChannelOutboundHandler) handler()).bind(this, localAddress, promise);
   } catch (Throwable t) {
       notifyOutboundHandlerException(t, promise);
   }
}
@Override
public void bind(
       ChannelHandlerContext ctx, SocketAddress localAddress, ChannelPromise promise)
       throws Exception {
   unsafe.bind(localAddress, promise);
}

最终由unsafe实现端口的bind操作。

public final void bind(final SocketAddress localAddress, final ChannelPromise promise) {
       if (!ensureOpen(promise)) {
           return;
       }
       try {
           boolean wasActive = isActive();
           ...        
           doBind(localAddress);
           promise.setSuccess();
           if (!wasActive && isActive()) {
               pipeline.fireChannelActive();
           }
       } catch (Throwable t) {
           promise.setFailure(t);
           closeIfClosed();
       }
   }
protected void doBind(SocketAddress localAddress) throws Exception {
   javaChannel().socket().bind(localAddress, config.getBacklog());
}

bind完成后,且ServerSocketChannel也已经注册完成,则触发pipeline的fireChannelActive方法,所以在这里可以自定义fireChannelActive方法,默认执行tail的fireChannelActive。

 @Override
public ChannelPipeline fireChannelActive() {
   head.fireChannelActive();
   if (channel.config().isAutoRead()) {
       channel.read();
   }
   return this;
}

channel.read()方法会触发pipeline的行为:

  @Override
public Channel read() {
   pipeline.read();
   return this;
}
@Override
public ChannelPipeline read() {
   tail.read();
   return this;
}
@Override
public ChannelHandlerContext read() {
   findContextOutbound().invokeRead();
   return this;
}
private void invokeRead() {
   EventExecutor executor = executor();
   if (executor.inEventLoop()) {
       invokeRead0();
   } else {
       Runnable task = invokeRead0Task;
       if (task == null) {
           invokeRead0Task = task = new Runnable() {
               @Override
               public void run() {
                   invokeRead0();
               }
           };
       }
       executor.execute(task);
   }
}
private void invokeRead0() {
   try {
       ((ChannelOutboundHandler) handler()).read(this);
   } catch (Throwable t) {
       notifyHandlerException(t);
   }
}

最终会在pipeline中找到handler执行read方法,默认是head。

至此为止,server已经启动完成。

目前在知识星球(https://t.zsxq.com/2VbiaEu)更新了如下 Dubbo 源码解析如下:

01. 调试环境搭建
02. 项目结构一览
03. API 配置(一)之应用
04. API 配置(二)之服务提供者
05. API 配置(三)之服务消费者
06. 属性配置
07. XML 配置
08. 核心流程一览
...
一共 60 篇++

RocketMQ MQClientInstance、生产者实例启动源码分析 该篇博文主要介绍 MQClientInstance 客户端实例以及 TopicRouteData 主题元数据信息,结合 Dashboard 看会更加的清晰,后续介绍了生产者实例启动的一个过程,其中介绍了几个核心的地方:NettyRemotingClient Netty 客户端、MQClientInstance#startScheduledTask 涉及到的定时调度任务、PullMessageService 推送模式作用的类、RebalanceService 重平衡服务 阅读详情

相关推荐

逆向工程Python爬虫——国税局发票查验平台

前言 这是一篇含金量很高的干货文章,笔者将手把手带领各位一步一步地实现爬取国家税务总局全国增值税发票查验平台(以下简称“查验平台”)。这个想法诞生在19年初,当时在做一款通过扫描二维码就可以查验发票的小程序。 当时由于笔者学艺尚浅,没办法模拟请求爬取查验平台,所以最终采用的技术方案是通过web自动化测试工具selenium控制浏览器去模拟查验步骤,即使这样,开发过程也是困难重重,不过最后笔者和伙伴们成功实现了整套流程,最后开发出的产品口袋发票夺得了包括2019微信小程序开发大赛赛区三等奖在内的多个奖项。 但

weixin_43102379的博客 1万+

Netty网络框架学习笔记-18(NioEventLoop源码与处理器异步任务分析)

netty-NioEventLoop源码与处理器异步任务分析

志豪的博客 405

Kali Linux实战:Aircrack-ng破解Wi-Fi密码的完整流程与常见问题解决

本文详细介绍了在Kali Linux中使用Aircrack-ng套件进行Wi-Fi密码破解的完整流程,包括环境准备、无线网卡配置、网络扫描、握手包捕获与字典破解等关键步骤。同时针对无线网卡不支持监听模式、无法捕获握手包等常见问题提供了实用解决方案,帮助安全研究人员有效评估无线网络安全性。

weixin_29323049的博客 300

Netty源码 ——EventLoop源码剖析02(四十五)

​​​​​​SingleThreadEventExecutor 队列中元素是实现了 Runnable 接口的对象,线程池中最重要的方法当然是 executer 方法,EventLoop 是 SingleThreadEventExecutor 的子类,那么EventLoop 类也可以直接调用 executer 方法来完成对事件的执行,我们来看源码。接着看 addTask 的实现。

prince~home 556

Python海康相机api---超简单入坑学习必看

海康官网下载相机驱动​安装好以后找到Python的开发文件目录参考:D:\MVS\MVS\Development\Samples\Python\MvImport这几个文件很重要,想调用海康相机取图会用到.​为了写代码方便可以把这几个文件拷贝一下,跟你的api主文件放在同一个文件夹下可以减少80%的烦恼.​。

weixin_59360687的博客 3481

uniapp [全端兼容] - 实现大文件上传分片/切片+本地选择文件上传超大文件,大文件切片上传+断点续传+上传进度条+失败自动重传,支持单个/批量上传图片、视频、文档各种文件(App、小程序、H5

uniapp 分片 断点续传 大文件上传。uniapp大文件切片上传,uniapp实现大文件上传 分片上传 进度条,分片上传附件,实现大文件上传,实现分片大文件上传,Uniapp实现大文件上传 分片上传 进度条,uniapp文件分片上传,uniapp如何上传很大的文件,在选择文件后,按指定大小将文件切割成独立的文件片,并逐片上传,uniapp 微信小程序上传大文件如何切片,uniapp APP实现大文件分片上传、断点续传、秒传,解决大文件上传问题,大文件上传如何做断点续传,uniapp上传视频,Uniapp

🏆 前端领域优质创作者 1万+

netty4.0.x源码分析—event

备注:本文的分析基于netty4.0.9final版本 1、event总体结构图 event总体结构类图如下: 2、event关键类和接口分析 1)基于NioEventLoop对关键类和接口进行分析,下面是它的关系图: EventExecutor 相当于只有一个EventExcutor的EventExecutorGroup,它的next方法返回的是自己的引用

pingnanlee的专栏 6013

告别 DEFINE VIEW:CDS View Entity 迁移全景实战(报表迁移 + ADT 向导 + 避坑清单)

CDS迁移的关键要点与策略 CDS DDIC-based View已被标记为废弃,迁移到CDS View Entity成为必要。迁移面临的主要挑战包括激活成本、命名约束和依赖风险。ABAP 7.57及以上版本必须优先处理,否则将积累技术债务。 迁移方式主要有两种: 报表路线:适合渐进式迁移的On-Premise项目 ADT向导:适合云环境批量迁移 关键注意事项: 必须提前检查SQL View依赖关系 金额/数量字段需要显式引用单位/货币字段 建议按使用场景分批迁移 最佳实践是结合报表进行系统盘点,再通过AD

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 209

Netty源码分析之服务启动

本节主要分析server的启动过程。 Netty是基于Nio实现的,所以也离不开selector、serverSocketChannel、socketChannel和selectKey等,只不过Netty把这些实现都封装在了底层。 从示例可以看出,一切从ServerBootstrap开始。 ServerBootstrap实例中需要两个NioEventLoopGroup实例,分别为b...

aikuangchou2298的博客 201

Hermes 教程 03:Skills 系统

摘要:Hermes Skills是一种自我改进机制,可将解决问题的经验保存为可复用技能文档。v0.13.0版本遵循agentskills.io开放标准,与Claude Skills互通。技能创建流程包括发现问题、创建技能文件、加载使用和优化更新四个阶段。系统提供技能检索和自维护机制(Curator),支持技能媒体路由和多种管理命令。内置技能涵盖开发调试、创意头脑风暴等场景,通过积累技能使Hermes更适应用户需求。

程序猿_三产 738

C/C++基础讲解(四十三)之图形篇之绘制直线、圆、圆弧、 椭圆

程序主要是基于Visual studio 2019进行编译完成了,有兴趣的小伙伴可以自己安装下Visual studio 2019,网上有现成的教程,当然了,如果有问题,也可以和我联系,这里我们主要讲解些源码实例,不多说了,言归正传。 C语言,做为学习其他语言的基础语言,其重要性就不言而喻了.下面我将和大家一起来学习探讨C语言的相关奥秘。 实例1:绘制直线 实例2:绘制圆 实例2:绘制圆弧 实例2:绘制椭圆

hnjzfwy的博客 1236

Netty启动源码&NioEventLoop剖析&accept剖析&read剖析&write剖析

入口关键代码(1、注意main线程和nio线程的切换;​ 2、initAndRegister 对应 nio中 创建ServerSocketChannel 和 把ServerSocketChannel注册到selector上​ 3、doBind0 对应 nio中 bind监听端口)// 1. 执行初始化和注册 regFuture 会由 initAndRegister 设置其是否完成,从而回调 3.2 处代码= null) {

pscool的博客 1418

【DaVinci Configurator专题】-2-将CAN 2.0或CANFD Matrix的Arxml/DBC文件导入到CFG

共9页 目录 1 打开DaVinci Configurator,导入Arxml文件 2 解决导入Arxml文件后可能会出现的一些错误 3 验证CFG的配置 4 根据CFG的配置生成代码 5 结尾 <--返回「实战篇」博文-总目录--> <--返回「Autosar从入门到精通-实战篇」专栏主页--> 关键词: Open the Input Files Assistant Complete update process Update ECU configurati

「汽车电子助手」的博客 6127

Netty服务端源码解析

Netty是一个基于Java NIO的网络编程框架,提供了简单而强大的API,用于快速开发可扩展的网络服务器和客户端应用程序。 Netty的设计目标是提供一个高性能、可维护、可扩展的网络编程框架。它的核心思想是通过提供异步事件驱动的网络应用程序开发模型,使得开发者可以轻松地构建高性能的网络应用程序。

子浩的博客 740

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

【Netty 专栏】Netty源码分析之NioEventLoop

点击上方“芋道源码”,选择“置顶公众号”技术文章第一时间送达!源码精品专栏 中文详细注释的开源项目Java 并发源码合集RocketMQ 源码合集Sharding-JDB...

芋道源码 453

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

Netty学习之旅----源码分析netty服务端初始化流程(Reactor主从模式实现)

5.1.2 调用init()方法,具体实现在ServerBootstrap,主要完成如下三件事: 1)用相关选项配置Channel(NioSocketChannel) 2)将childHandler(ChannelInitializer子类handler)加入到管道,已便后续注册应用程序编排的处理链条(Handler)。 3)增加ServerBootstrapAcceptor,Handler处理器,主要是channelRead事件的处理,后续会重点讲解。 5.2 调用gourp().register()方法

m0_64867839的博客 199

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

深入浅出学 Netty

内容亮点 扎实的 Java 网络理论知识分析:线程模型、并发安全设计、逻辑事件概念模型、IO 模型,异步编程、全面的理论知识打牢 Java 网络编程的基础。 详尽的 Netty 示例讲解与实战演练:针对每一个知识点,都提供了详尽的代码示例,让抽象的知识变得直观;采用生产项目作为实战对象,将理论知识和实际项目联系起来,在实战中进一步丰富对 Netty 的理解。 深入细致的 Netty 源码分析:从...

GitChat 1171

Netty服务端创建源码流程解析

本专栏基于4.1.73.Final版本进行解析 相信大家对创建一个Netty服务端已经很熟悉了,下边是一个简单的服务端的例子: public final class EchoServer { static final boolean SSL = System.getProperty("ssl") != null; static final int PORT = Integer.parseInt(System.getProperty("port", "8007")); publ.

940

【Netty 专栏】Netty源码分析之ChannelPipeline

点击上方“芋道源码”,选择“置顶公众号”技术文章第一时间送达!源码精品专栏中文详细注释的开源项目Java 并发源码合集RocketMQ 源码合集Sharding-JDBC 源码解析合集...

芋艿V 113

【RocketMQ 源码分析(一)】设计理念与源码阅读技巧

设计一款消息队列中间件,首先它需要对外提供通信路口,提供生产、消费消息的路口,即需要具备网络通信能力;其次就是它得具备数据存储的能力,这数据包含消息本身与元数据存储。

qq_63691275的博客 924

从源码全面解析 dubbo 服务暴露的来龙去脉

对于 Java 开发者而言,关于 dubbo ,我们一般当做黑盒来进行使用,不需要去打开这个黑盒。但随着目前程序员行业的发展,我们有必要打开这个黑盒,去探索其中的奥妙。本期 dubbo 源码解析系列文章,将带你领略 dubbo 源码的奥秘。本期源码文章吸收了之前 Spring、Kakfa、JUC源码文章的教训,将不再一行一行的带大家分析源码,我们将一些不重要的部分当做黑盒处理,以便我们更快、更有效的阅读源码。虽然现在是互联网寒冬,但乾坤未定,你我皆是黑马!

爱敲代码的小黄 2821

netty学习1

1、初始化EventLoopGroup,并设置接受新socket的线程数量。 在创建接受新socket的EventLoopGroup时  EventLoopGroup bossGroup = new NioEventLoopGroup(8); NioEventLoopGroup(MultithreadEventLoopGroup).(int nThreads, ThreadFac

sunning9001的专栏 685

Netty4 Channel 概述

《让天下没有难学的Netty》系列,基于 Netty,以源码分析为主要手段,关键流程给出流程图,从 通道篇、内存篇、性能篇三个维度深度剖析 Netty 的实现原理。

中间件兴趣圈 3205

CAT源码分析5 - 服务端消息接收

CAT源码分析5 - 服务端消息接收 1. TcpSocketReceiver初始化 在CAT服务端启动初始化过程中,CatHomeModule在初始化时,会通过setUp()和execute()两个方法实现对消息接收器的初始化。 通过setUp方法完成对Netty客户端网络通信的初始化 execute方法中有其他功能的初始化逻辑,包括对消息消费者的初始化 整体的初始化逻辑如下图 ![image.png](https://img-blog.csdnimg.cn/img_convert/c9f0b5659

AKA毅成的博客 624
上一篇: 注册中心 Eureka 源码解析 —— 应用实例注册发现 (三)之下线
下一篇: 分布式作业系统 Elastic-Job-Lite 源码分析 —— 作业分片
公众号-芋道源码
博客等级 码龄10年 1639粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值