ReintyPan
ReintyPan

Netty服务端流程源码分析（Netty4.1.25）

Netty的4个重要内容

通过阅读Netty的相关实现，刚好看到网上的一篇文章给的总结，觉得挺适合作为Netty的核心内容来研究的
1.Reactor线程模型：高性能多线程设计思路
2.Netty中自己定义的channel概念：增强版的NIOchannel
3.ChannelPipeline责任链设计模式：事件处理机制
4.内存管理：增强型byteBuf缓冲区

Server端启动相关代码例子

public static void main(String[] args) throws Exception {
    EventLoopGroup pGroup = new NioEventLoopGroup(1);
    EventLoopGroup cGroup = new NioEventLoopGroup();
    ServerBootstrap b = new ServerBootstrap();
    b.group(pGroup, cGroup)

            // Server端 NioServerSocketChannel.class，Client 端 NioSocketChannel.class
            .channel(NioServerSocketChannel.class)

            // options.put(option, value)
            .option(ChannelOption.SO_BACKLOG, 1024)

            // childOptions.put(childOption, value);
            .childOption( ChannelOption.SO_TIMEOUT, 20000)

            // 设置 handler 属性，
            .handler(new LoggingHandler(LogLevel.INFO))

            // 设置 childHandler 属性（多个可以用 ChannelInitializer 来设置）
            .childHandler(new ChannelInitializer() {
                protected void initChannel(SocketChannel sc) throws Exception {
                    sc.pipeline().addLast(new NettyMessageDecoder<>(AttachmentRequest.class, ProtostuffSerializer.class, 1 << 20, 2, 4));
                    sc.pipeline().addLast(new NettyMessageEncoder<>(ResponseBean.class, ProtostuffSerializer.class));
                    sc.pipeline().addLast(new ServerHandler());
                }
            });

    ChannelFuture cf = b.bind(8765).sync();

    cf.channel().closeFuture().sync();
    pGroup.shutdownGracefully();
    cGroup.shutdownGracefully();

}

NioEventLoopGroup 创建以及初始化工作

我们通常会通过下面代码来实例化两个 Group

EventLoopGroup pGroup = new NioEventLoopGroup(1);

EventLoopGroup cGroup = new NioEventLoopGroup();

当我们通过 new NioEventLoopGroup() 实例化一个 NioEventLoopGroup 对象时，由于继承关系 NioEventLoopGroup --> MultithreadEventLoopGroup --> MultithreadEventExecutorGroup。通过 NioEventLoopGroup 的构造器调用链，我们直接来到其父类 io.netty.util.concurrent.MultithreadEventExecutorGroup 构造器中进行分析相关实现逻辑

protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
                                        EventExecutorChooserFactory chooserFactory, Object... args) {
    if (nThreads <= 0) {
        throw new IllegalArgumentException(String.format("nThreads: %d (expected: > 0)", nThreads));
    }

    if (executor == null) {
        executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
    }

    children = new EventExecutor[nThreads];

    for (int i = 0; i < nThreads; i ++) {
        boolean success = false;
        try {
            children[i] = newChild(executor, 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) {
               // 关闭资源
                }
            }
        }
    }

    chooser = chooserFactory.newChooser(children);

    final FutureListener terminationListener = new FutureListener() {
        @Override
        public void operationComplete(Future future) throws Exception {
            if (terminatedChildren.incrementAndGet() == children.length) {
                terminationFuture.setSuccess(null);
            }
        }
    };

    for (EventExecutor e: children) {
        e.terminationFuture().addListener(terminationListener);
    }

    Set childrenSet = new LinkedHashSet(children.length);
    Collections.addAll(childrenSet, children);
    readonlyChildren = Collections.unmodifiableSet(childrenSet);
}
 
 
NioEventLoopGroup 线程数
 
 
 
  
初始化NioEventLoopGroup时，如果我们设置线程数，则会根据我们设置的线程数来在需要的时候创建线程，如果不设置，则首先根据如下代码获取可创建的线程数：
 
 
 
 
SystemPropertyUtil.getInt("io.netty.eventLoopThreads", NettyRuntime.availableProcessors() * 2);
//首先是检查我们是否配置了 io.netty.eventLoopThreads 参数，如果没配置则根据当前 JVM 可使用的 CPU 数量乘以2 来初始化线程数。

 
 
1、初始化 executor 变量
 
 
NioEventLoopGroup创建过程中，会递归调用父类的构造器完成相应的初始化操作，在父类 MultithreadEventExecutorGroup 中会执行一个 executor变量的初始化，此变量是一个 ThreadPerTaskExecutor 类型，也就是需要实例化一个 ThreadPerTaskExecutor 对象赋值给 executor，而实例化 ThreadPerTaskExecutor 时需要传入一个 ThreadFactory 对象作为构造参数，在 MultithreadEventExecutorGroup 类中是通过实例化 DefaultThreadFactory 对象作为 ThreadFactory 参数传入的。
 
 
就如 ThreadPerTaskExecutor 名称所示，只要我们调用 execute(Runnable command) 方法来提交任务，此executor就会新建一个线程来执行任务。
 
 
2、初始化 children 数组并完成各个元素的实例化
 
 
     
  
  1. 根据线程数来创建一个 children 数组（长度为线程数），数组类型是 EventExecutor 类型的；
    2.  
  
  2. 循环为每个元素初始化一个 NioEventLoop 对象（由子类来创建EventLoop 对象）；需要传入两个参数，一个是 上一步始化好的 executor 对象，一个是 NioEventLoopGroup 中传来的参数信息，包括的元素为： SelectorProvider，SelectStrategyFactory ，RejectedExecutionHandler 此三个元素。在 NioEventLoop 构造方法被调用时（包括父类构造方法）主要做了如下工作：
    3.  
 
 
 
     
  
  • 【1】在超类 SingleThreadEventLoop 中创建了一个引用为 tailTasks 的 LinkedBlockingQueue 队列。
    •  
  
  • 【2】 在超类 SingleThreadEventExecutor 中也创建了 一个引用为 taskQueue 的 LinkedBlockingQueue 队列。
    •  
  
  • 【3】 NioEventLoop 把 所属的 NioEventLoopGroup 对象以 parent 变量传给超类，并存入超类的 parent 变量中。
    •  
  
  • 【4】初始化 Nio Selector 对象信息，
    •  
  
  • 【5】初始化 NioEventLoop 的 executor 信息，此信息是公用 MultithreadEventExecutorGroup 中的 executor 实例（复用）所以后面逻辑 每个 NioEventLoop 都各自执被调用 execute 提交任务并启动 EventLoop线程来执行 selector.select() 获取就绪事件并调用 pipeline中的 handler进行处理，以及执行 taskQueue中的方法（也就是各自启动一个线程来执行自己的 selector 事件 以及执行自己 taskQueue中的任务）；
    •  
 
 
 
其中上面的两个队列长度，最小为 16 ，最大为 Integer.MAX , 取决于 io.netty.eventLoop.maxPendingTasks 参数
 
 
DEFAULT_MAX_PENDING_TASKS = Math.max(16, SystemPropertyUtil.getInt("io.netty.eventLoop.maxPendingTasks", Integer.MAX_VALUE))

 
 
以上 SystemPropertyUtil.getInt( v1, v2) : 如果v1 不为空返回 v1, 否则范湖 v2;
 
 
3、初始化 chooser 对象
 
 
chooser 对象是根据上一步初始化好的 children 数组长度来创建一个 EventExecutorChooser 对象；其中根据 children 数组元素个数是否是 2的N 次方来看是实例化 PowerOfTowEventExecutorChooser 还是实例化 GenericEventExecutorChooser ；其中两个功能都是一样，根据任务数取余来获取 children 中的 NioEventLoop 对象；但当 children 的元素个数是 2 的 N 次方时可以根据“与运算” 来取余，速更度快。
 
 
4、为 children 数组中的每个 NioEventLoop 添加一个 terminationListener
 
 
首先是创建一个 FutureListener 实例作为 terminationListener ，然后循环 children 为每个元素（的 terminationListener ）注册一个FutureListener ，此监听器的实现就是当当 terminatedChildren 数值等于 children.length 的时候，则调用 terminationFuture.setSuccess(null) ，具体作用和具体什么场景下调用应该是终止程序有关。
 
 
其中 e.terminationFuture() 返回的是 NioEventLoop 的父类 SingleThreadEventExecutor 中的 terminationFuture 值。
 
 
5、最后完成 readonlyChildren 的初始化
 
 
最后剩余的代码就是根据 children 中的元素来生成一个不可变的 Set 集合，并赋值给 readonlyChildren 变量，方便后续的遍历
 
 
ServerBootstrap 初始化以及启动流程分析
 
 
ServerBootstrap创建以及初始化工作
 
 
ServerBootstrap 创建时，会完成相关全局变量的初始化（包括一些集合等信息）
 
 
public class ServerBootstrap extends AbstractBootstrap {

private static final InternalLogger logger = InternalLoggerFactory.getInstance(ServerBootstrap.class);

private final Map, Object> childOptions = new LinkedHashMap, Object>();

private final Map, Object> childAttrs = new LinkedHashMap, Object>();

private final ServerBootstrapConfig config = new ServerBootstrapConfig(this);

private volatile EventLoopGroup childGroup;

private volatile ChannelHandler childHandler;

public ServerBootstrap() { }


 
 
当我们调用 ServerBootstrap 默认构造参数来创建 ServerBootstrap 对象时，会执行全局参数的初始话， 包括父类的 options 和 attrs 集合信息（也就是为 childGroup parentGroup 分别初始化好这些集合信息），这些集合为我们后面传入的初始化信息做保存的，因此后面我们就可以通过调用 ServerBootstrap 相关方法来完成相应属性的初始化工作，类似；
 
 
ServerBootstrap b = new ServerBootstrap();
b.group(pGroup, cGroup)

        // Server端 NioServerSocketChannel.class，Client 端 NioSocketChannel.class
        .channel(NioServerSocketChannel.class)

        // options.put(option, value)
        .option(ChannelOption.SO_BACKLOG, 1024)

        // childOptions.put(childOption, value);
        .childOption( ChannelOption.SO_TIMEOUT, 20000)

        // 设置 handler 属性，
        .handler(new LoggingHandler(LogLevel.INFO))

        // 设置 childHandler 属性（多个可以用 ChannelInitializer 来设置）
        .childHandler(new ChannelInitializer() {
            protected void initChannel(SocketChannel sc) throws Exception {
                sc.pipeline().addLast(new NettyMessageDecoder<>(AttachmentRequest.class, ProtostuffSerializer.class, 1 << 20, 2, 4));
                sc.pipeline().addLast(new NettyMessageEncoder<>(ResponseBean.class, ProtostuffSerializer.class));
                sc.pipeline().addLast(new ServerHandler());
            }
        });

 
 
调用 Bootstrap#bind(int) 方法完成相应信息的绑定以及注册
 
 
对应例子中的如下bind() 方法
 
 
ChannelFuture cf = b.bind(8765).sync()

 
 
最终调用到 io.netty.bootstrap.AbstractBootstrap#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.registered();

                    doBind0(regFuture, channel, localAddress, promise);
                }
            }
        });
        return promise;
    }
}

 
 
接下来我们根据源码进行分析
 
 
NioServerSocketChannel的创建以及EventLoop的注册
 
 
在doBind() 方法中通过调用 initAndRegister() 来完成Channel 的初始化以及完成Channel到EventLoop的注册逻辑
 
 
1. 根据 channelFactory创建一个 Channel 实例，服务端这里对应的是 NioServerSocketChannel 实例
 
 
     
  
  • 【1】在创建 NioServerSocketChannel 时会根据 java.nio.channels.spi.SelectorProvider#openServerSocketChannel 创建一个 ServerSocketChannel 实例，此实例信息被记录在父类 AbstractNioChannel 的 ch 变量中（后续可调用 AbstractNioChannel#javaChannel() 获取），并设置 ch.configureBlocking(false) 以及 readInterestOp = SelectionKey.OP_ACCEPT
    •  
  
  • 【2】同时初始化 unsafe 变量以及 pipeline = new DefaultChannelPipeline(this);
    •  
  
  • 【3】 调用 config = new NioServerSocketChannelConfig(this, javaChannel().socket()) 完成 config的初始化，此初始化会创建一个 AdaptiveRecvByteBufAllocator 实例来为 channel 管理 ByteBuffer信息（扩容缩容等）；
    •  
 
 
 
2. 调用ServerBootstrap#init( channel ) 初始化Channel信息
 
 
     
  
  • 【1】根据 options 信息以及 attrs 信息初始化NioServerSocketChannel 对象信息（以备 NIO channel使用）
    •  
  
  • 【2】调用 channel.pipeline() 获取上面创建的 pipeline 对象 （DefaultChannelPipeline ），然后调用 pipeline 的 addLast( ChannelHandler )方法首先添加 bootstrap 中配置的 handler 信息，然后提交一个任务到 channel eventLoop 中，此任务是为 当前Pipeline 添加一个 ServerBootstrapAcceptor 类型的Handler信息，整体代码为：
    •  
 
 
 
p.addLast(new ChannelInitializer() {
    @Override
    public 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() {
            @Override
            public void run() {
                pipeline.addLast(new ServerBootstrapAcceptor(
                        ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
            }
        });
    }
});

 
 
 
  
【重点】在 DefaultChannelPipeline#addLast( ChannelHandler)方法中，首先会根据当前的 ChannelHandler来创建 ctx 实例并插入到 pipeline中，同时会调用 ChannelHandler#handlerAdded() 方法，而 ChannelInitializer#handlerAdded() 方法中又调用了 ChannelInitializer#initChannel() 方法，所以会轮训调用到 我们实现的 initChannel() 来完成相关 Handler 的加入逻辑；
 
 
 
 
以上代码中的 channel 目前还未配置上 eventLoop 变量信息，需要在下面的 register(channel) 进行注册之后才配置上 EventLoop；
 
 
3. 完成 Channel 到 EventLoop 以及对应的 Selelctor 的注册
 调用 ChannelFuture regFuture = config().group().register(channel) 并返回此 regFutre 对象（DefaultChannelPromise 类型）；在创建 NioEventLoopGroup 时就通过 config = new ServerBootstrapConfig(this) 初始化了 config 变量；所以此处的 config().group()获取的是注入ServerBootstrap 中的 NioEventLoopGroup 对象（return bootstrap.group()），也就是 parentGroup 信息；
 
 
     
  
  • 【1】调用 MultithreadEventLoopGroup#register(io.netty.channel.Channel) 方法，在此方法中 调用 next().register(channel) 来完成相关业务逻辑
    •  
  
  • 【2】next() 方法的逻辑 是调用 MultithreadEventExecutorGroup#chooser 中的 next() 方法来获取下一个 NioEventLoop 类型的 EventExecutor 信息，实现逻辑就是 chooser 内部维护一个AtomicInteger idx， 根据 idx.getAndIncrement() 来与 children 数组长度求余来获取数组中的元素并返回；实现的策略根据任务数取余来获取 children 中的 NioEventLoop 对象；但当 children 的元素个数是 2 的 N 次方时 可以根据位与运算来取余，速更度快；
    •  
  
  • 【3】由于 Eventloop 都继承于 SingleThreadEventLoop 所以 最终会调用 SingleThreadEventLoop#register(Channel) 来完成相关逻辑最终调用链：AbstractChannel 类中的 AbstractUnsafe#register -> SingleThreadEventExecutor#execute() --> SingleThreadEventExecutor#addTask() ； 最后返回 DefaultChannelPromise 实例信息
    •  
 
 
 
AbstractChannel 类中的 AbstractUnsafe#register() ：初始化当前的 AbstractChannel.this.eventLoop = eventLoop ， 也就是完成当前channel 到 NioEventLoop 的绑定；提交 pipeline 任务到 taskQuene 任务列表中（由于不是 eventLoop执行线程，所以以任务方式提交执行内容，也就是调用 SingleThreadEventExecutor#execute() 提交 Runnable），并通过 CAS 来启动 NioEventLoop中的线程；大概流程为：
 
 
 
  
SingleThreadEventExecutor#execute( Runnable ) --> SingleThreadEventExecutor#addTask() (如果添加task 失败则调用拒绝策略 rejectedExecutionHandler.rejected(task, this) ) ； 并且判断当前线程是不是负责执行 EventLoop 中的任务（SingleThreadEventExecutor#taskQueue）的线程，如果是则直接退出，否则调用 SingleThreadEventExecutor#startThread() 通过 CAS来尝试启动 SingleThreadEventExecutor 中的线程（如果启动过了则不执行任何逻辑，否则通过向 ThreadPerTaskExecutor 提交一个 Runable 来启动线程执行任务信息）—— 所以如上提到，虽然 SingleThreadEventExecutor 每次提交任务都会启动一个新线程来执行，但一个 SingleThreadEventExecutor 只会提交一次（CAS成功才提交），并且 SingleThreadEventExecutor 中的线程运行之后会一直循环拉取 selector中就绪的事件和 taskQueue中的任务，直到异常或者程序终止；
 
 
 
 
再次总结上面的执行的逻辑：
 
 
     
  
  • （1）完成 channel 到给定的（通过 chooser 选择得到的） eventLoop 的绑定任务；
    •  
  
  • （2）提交Runnable 任务到 eventLoop 的 taskQuene中, 并通过 CAS 检查是否需要启动 eventLoop 的线程（线程会运行 NioEventLoop#run()），如果未启动则进行启动，否则忽略；
    •  
 
 
 
io.netty.channel.AbstractChannel.AbstractUnsafe#register 代码如下：
 
 
public final void register(EventLoop eventLoop, final ChannelPromise promise) {
// ........异常检查等逻辑删除
    AbstractChannel.this.eventLoop = eventLoop;
    if (eventLoop.inEventLoop()) {
        register0(promise);
    } else {
        try {
            eventLoop.execute(new Runnable() {
                @Override
                public void run() {
                    register0(promise);
                }
            });
        } catch (Throwable t) {
        }
    }
}

private void register0(ChannelPromise promise) {
    try {
        if (!promise.setUncancellable() || !ensureOpen(promise)) {
            return;
        }
        boolean firstRegistration = neverRegistered;

        // 完成 nio channel 到 nio selector 的注册，其中兴趣事件值为0
        doRegister();
        neverRegistered = false;
        registered = true;
        // 会检查是否有 pending Handler 完成 handlerAdded 方法的调用，也就是确保标记channel 为 registration 之前确保所有 handler 都加入到 pipeline中
        pipeline.invokeHandlerAddedIfNeeded();
       
         // 标记此 future为成功状态，并通知listeners列表，把  io.netty.util.concurrent.DefaultPromise#result 字段标记为 SUCCESS
        safeSetSuccess(promise);
        // 传播 channelRegistered事件（追踪主流程handler（head + tail ），没发现做什么处理）
        pipeline.fireChannelRegistered();
        //  isActive() 逻辑是判断是否已完成端口号的绑定，如果已完成则完成 channel active 事件在 pipeline 上的传播.
        if (isActive()) {
            if (firstRegistration) {
                pipeline.fireChannelActive();
            } else if (config().isAutoRead()) {
                // See https://github.com/netty/netty/issues/4805
                beginRead();
            }
        }
    } catch (Throwable t) {
}

 
 
     
  
  • 【4】channel 到 selector 的绑定
    •  
 
 
 
其中 register0 方法中的 doRegister() 方法是完成 nio Channel 到 selector 的注册逻辑，此处注册的兴趣事件为 0 ，并把当前channel 作为 attach 信息:
 
 
selectionKey = javaChannel().register(eventLoop().unwrappedSelector(), 0, this);

 
 
isActive() 逻辑是判断是否已完成端口号的绑定，如果已完成则执行 channel active 事件在 pipeline 上的传播.由于绑定端口号是在后面逻辑完成，所以此处暂不分析，也就是到目前，channel 虽然注册到selector 上了，但注册的兴趣事件是空的，也就是 ops 为0，后续我们再找找在哪里注册上了 ACCPT事件（值为16）；
 
 
至此 final ChannelFuture regFuture = initAndRegister() 逻辑分析完毕；
 
 
调用 doBind0(regFuture, channel, localAddress, promise) 完成端口号的绑定
 
 
首先是根据 regFuture.isDone() 来判断当前Future 是否已执行完成，如果已完成则直接调用 dobind0() 方法进行端口号的绑定，否则添加一个 pending 任务，把绑定逻辑传给 regFuture 的监听列表，等Futrue 逻辑处理完成后再进行监听列表的回调来完成绑定逻辑的调用：由于上面 register0() 中已调用 safeSetSuccess(promise) 把 futrue result 标记为 SUCCESS, 所以此处的 isDone() 返回true, 也就是直接调用 doBind0(regFuture, channel, localAddress, promise) 进行端口号的绑定， 然后返回 promise 对象。
 
 
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.registered();

                doBind0(regFuture, channel, localAddress, promise);
            }
        }
    });
    return promise;
}

 
 
而 doBindo() 方法的逻辑就是给当前 channel 的 eventLoop 提交一个 bind 任务，也就是调用 SingleThreadEventExecutor#execute( Runnable ) 提交一个任务；任务功能是完成端口号的绑定，调用任务链为：
 
 
 
  
DefaultChannelPipeline#bind(SocketAddress, ChannelPromise) ---> AbstractChannel#bind(SocketAddress,ChannelPromise) --> tail.bind(localAddress, promise) ..........tail --> head方向....... --> DefaultChannelPipeline.HeadContext#bind() ----> AbstractUnsafe#bind() -->AbstractUnsafe#bind ---》 NioServerSocketChannel#doBind --》javaChannel().socket().bind(localAddress, config.getBacklog()) （Nio 的端口绑定逻辑）绑定完后，调用 promise.trySuccess() 进行标记（ Marks this future as a success and notifies all listeners. ）
 
 
 
 
而重要逻辑在 AbstractChannel.AbstractUnsafe#bind 方法中，源代码如下（仅留要分析的重要代码）：
 
 
public final void bind(final SocketAddress localAddress, final ChannelPromise promise) {
    assertEventLoop();

    boolean wasActive = isActive();
    try {
        doBind(localAddress);
    } catch (Throwable t) {
    }

    if (!wasActive && isActive()) {
        invokeLater(new Runnable() {
            @Override
            public void run() {
                pipeline.fireChannelActive();
            }
        });
    }

    safeSetSuccess(promise);
}

 
 
完成端口号的绑定逻辑
 
 
首先 bind 的调用会通过 DefaultChannelPipeline ，从 tail 方向开始，流入head， 最终在 DefaultChannelPipeline.HeadContext#bind()中调用到 AbstractUnsafe#bind() 方法；
 
 
AbstractUnsafe#bind ---> NioServerSocketChannel#doBind --> javaChannel().socket().bind(localAddress, config.getBacklog()) ；
 
 
最终到 java.net.ServerSocket#bind(java.net.SocketAddress, int) 方法中，此处便是熟悉的 NIO Server 端端口号的绑定了；其实Netty对端口号的绑定也没什么复杂的逻辑，只是需要通过 pipeline 调用 bind 从 tail 方向传播到 head 方向；最终在 head 时调用 unsafe 来调用 jdk 完成 server 端口的绑定；
 
 
通过pipeline.fireChannelActive() 的调用完成 ACCEPT 事件的绑定
 
 
在之前的 channel 到 selector 的绑定中，只是注册了 ops 为0 ，也就是并绑定任何事件信息。而真正 ACCEPT 事件绑定是在此处代码才完成绑定的
 
 
上面方法中，对于 if (!wasActive && isActive()) 的判断，其实就是判断在调用 doBind 之前， javaChannel().socket().isBound() 是false， 而在调用之后，返回true, 也就是之前socket是未绑定，调用 doBind 后完成了绑定的情况 则会调用到if里面的逻辑。
 
 
也就是往 eventLoop 的任务列表中插入一条对 pipeline.fireChannelActive() 进行调用的任务；此方法会调用 AbstractChannelHandlerContext.invokeChannelActive(head) 方法，也就是从pipeline 的 head 方向往 tail 方向调用channelActive() 方法 ，而在 DefaultChannelPipeline.HeadContext#channelActive 方法中：
 
 
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
    ctx.fireChannelActive();

    readIfIsAutoRead();
}

private void readIfIsAutoRead() {
    if (channel.config().isAutoRead()) {
        channel.read();
    }
}

 
 
也就是会判断 channel # config # isAutoRead 是否为true, 为true 的话则调用 channel.read() 方法。而默认则是返回 true的，所以会调用 channel read(); 也就是会从 tail.read() ----> head.read() 方向进行调用，最终在 HeadContext#read 方法中进行 AbstractUnsafe#beginRead() 方法的调用，最终调用 AbstractNioChannel#doBeginRead，源码如下：
 
 
@Override
protected void doBeginRead() throws Exception {
    // Channel.read() or ChannelHandlerContext.read() was called
    final SelectionKey selectionKey = this.selectionKey;

    final int interestOps = selectionKey.interestOps();
    if ((interestOps & readInterestOp) == 0) {
        selectionKey.interestOps(interestOps | readInterestOp);
    }
}

 
 
其中 AbstractNioChannel#readInterestOp 变量在上面我们也有提到过，在实例化 NioServerSocketChannel 时会设置 ch.configureBlocking(false) 以及 readInterestOp = SelectionKey.OP_ACCEPT；因此也就在此步完成了 channel ACCEPT 事件的绑定；
 
 
调用 safeSetSuccess(promise) 执行 future SUCCESS 标记
 
 
此逻辑在上面也大概提过，就是把promise 的 result 尝试标记为 CUCCESS并完成此 future中的 listeners 列表的信息的回调; 也就是上面提到的调用 promise.trySuccess() 进行标记（ Marks this future as a success and notifies all listeners. ）
 
 
NioEventLoop#run() 代码逻辑分析
 
 
每个EventLoop 都会对应一个线程，并在线程中 for 循环：
 
 
     
  
  1. 拉取自己 Selector 上的 Channel 事件信息（READ、WRITE、 ACCEPT、 CONNECTION）;
    2.  
  
  2. 调用 processSelectedKeys() 处理 Channel 事件，包括传播到 channel 对应的 pipeline 中由各个 handler 处理
    3.  
  
  3. 执行 taskQueue 中的任务，确保提交的任务都有机会执行
    4.  
 
 
 
io.netty.channel.nio.NioEventLoop#run() 源码如下(部分已删除)：
 
 
@Override
protected void run() {
    for (;;) {
        try {
            switch (selectStrategy.calculateStrategy(selectNowSupplier, hasTasks())) {
                case SelectStrategy.CONTINUE:
                    continue;
                case SelectStrategy.SELECT:
                    select(wakenUp.getAndSet(false));
                    if (wakenUp.get()) {
                        selector.wakeup();
                    }
                    // fall through
                default:
            }
            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() 拉取准备事件
 
 
首先根据任务列表（taskQueue、tailTasks）是否为空来执行 select() 的策略，执行完select（） ，主要是执行 selecteNow() 还是 select( timeOut), 以及确定 timeOut 的时间（默认是一秒）
 
 
调用 processSelectedKeys() 处理就绪事件
 
 
1、获取事件
 
 
在 NioEventLoop#openSelector() 方法中，在创建 nio selector 对象时，nettty 通过判断 io.netty.noKeySetOptimization 参数来决定是否执行 selector 的相关优化功能，如果执行优化操作的话，netty会通过 反射把 SelectorImpl#publicKeys 和 SelectorImpl#publicSelectedKeys 对象置换成自己的 SelectedSelectionKeySet 对象，然后把 nio selector 封装成一个 SelectedSelectionKeySetSelector 对象，具体优化可以查看相关代码，由于默认没配置，所以此处不进行优化代码逻辑的剖析；
 
 
在执行完 select() 操作之后就可以通过 selector.selectedKeys() 来获取就绪事件的集合，接着执行事件的处理逻辑，对应的 NioEventLoop#processSelectedKeysPlain() 的部分源码如下 ：
 
 
private void processSelectedKeysPlain(Set selectedKeys) {
    Iterator 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 task = (NioTask) a;
            processSelectedKey(k, task);
        }
        if (!i.hasNext()) {
            break;
        }
    }
}

 
 
首先判断 SelelctionKey # attachment() 对象是否属于 AbstractNioChannel 类型，其中在上面我们已经分析过 （其中 register0 方法中的 doRegister() 方法是完成 nio Channel 到 selector 的注册逻辑，并把当前channel 作为 attach 信息），所以此处的 attachment 是属于 AbstractNioChannel 类型的，所以会走到 NioEventLoop#processSelectedKey( SelectionKey, AbstractNioChannel) 的方法逻辑：
 
 

private void processSelectedKey(SelectionKey k, AbstractNioChannel ch) {
    final AbstractNioChannel.NioUnsafe unsafe = ch.unsafe();
    if (!k.isValid()) {
        // 略.......
        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/924
            int 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 write
            ch.unsafe().forceFlush();
        }

        // Also check for readOps of 0 to workaround possible JDK bug which may otherwise lead
        // to a spin loop
        if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) {
            unsafe.read();
        }
    } catch (CancelledKeyException ignored) {
        unsafe.close(unsafe.voidPromise());
    }
}

 
 
OP_CONNECT是客户端事件，OP_WRITE 是我们给channel写入数据时触发的事件（目前我们也没有注册 WRITE事件），所以此处我们只分析最后一种情况，也就是 OP_READ | OP_ACCEPT 事件的情况；因此走到 unsafe.read() 方法的调用。
 
 
2、根据事件获取信息
 
 
 
  
首先我们先来看看 channel 的 unsafe.read()， unsafe 有两种实现（为了兼容各种数据类型，pipeline数据传递使用了 Object 作为数据类型）：
 NioByteUnsafe # read ：此实现逻辑是通过channel 来读取数据信息，然后在pipeline中传播 channelRead( Object ) 事件和 channelReadComplete（）事件，也就是真正读取 socket buffer 中的数据信息 并从 pipelien 的 head 往 tail 方向传播读取的数据信息，；
 NioMessageUnsafe # read： 此实现并不是从 channel 中读取事件信息，而是通过 ServerSocketChannel accept 来获取 SocketChannel, 并把 SocketChannel 封装成一个 NioSocketChannel 放入readBbuffer 数组中，接着再获取出来，然后同样在pipeline中传播 channelRead( Object ) 事件和 channelReadComplete（）事件，并从 pipelien 的 head 往 tail 方向传播获取的 NioSocketChannel 对象信息，
 
 
 
 
而对于此次 Netty分析，到目前我们只是分析到 Server 端 ParentGroup 启动过程，在上面的 unsafe.read() 方法调用的其实是 NioMesaageUnsafe # read 的方法，依据是：unsafe 是通过调用 channel#unsafe() 获取的，而我们此处的 channel 对应的是 NioServerSocketChannel, 而 NioServerSocketChannel 的 unsafe 是在父类 AbstractNioMessageChannel 中创建的，也就是AbstractNioMessageChannel.NioMessageUnsafe 类型的unsafe, 所以调用链为 NioMessageUnsafe#read() --> NioServerSocketChannel#doReadMessages() ， 对应 NioServerSocketChannel#doReadMessages() 源码如下(删减)：
 
 
@Override
protected int doReadMessages(List buf) throws Exception {
    SocketChannel ch = SocketUtils.accept(javaChannel());
    try {
        if (ch != null) {
            buf.add(new NioSocketChannel(this, ch));
            return 1;
        }
    } catch (Throwable t) { 
    } 
    return 0;
}
 
 
以上我们便分析完了信息的获取逻辑，下面我们分析创建NioSocketChannel 中做了哪些工作；
 
 
3、NioSocketChannel 的创建
 
 
在上面逻辑中我们已经分析了 NioServerSocketChannel 创建的相关逻辑，其实NioSocketChannel 的创建同样也需要完成相关功能的创建以及初始化工作，下面我们简单对比一下相关逻辑：
 
 
 
  
 
   
  
   
 
  
 
  

    channel.png 
  
 
 
 
 
 
  
从类的关系图中可以看出 NioSocketChannel 继承自 AbstractNioByteChannel , NioServerSocketChannel 继承自 AbstractNioMessageChannel, 而这两个 AbstractXXXChannel 都继承自 AbstractNioChannel;
 
 
 
 
     
  
  • AbstractNioByteChannel : 内部维护了一个 NioByteUnsafe，通过此 unsafe 来为外部提供 read、write 方法的调用，然后此read/write 方法会调用AbstractNioByteChannel 的 doReadBytes / doWriteBytes 方法（抽象方法），而在 NioSocketChannel 类中对这两方法进行了实现，大概实现逻辑就是从 SocketChannel 中读取网络传入的数据信息或者写入数据信息；上面说的NioByteUnsafe # read 所提供的功能正是在AbstractNioByteChannel.doReadBytes () 中进行实现的；
    •  
  
  • NioServerSocketChannel: 内部维护了一个 NioMessageUnsafe，同样通过此 unsafe 来给外部提供 read、write 方法的调用，不同的是 NioServerSocketChannel 为 unsafe 提供的是 doReadMessages / doWriteMessage 方法，对于 doReadMessages 方法的功能，正是我们上面说的 NioMessageUnsafe # read 功能，也就是 通过 serverSocket.accept() 获取到 SocketChannel 对象的功能，而对于 doWriteMessage , NioServerSocketChannel 实现是抛出 UnsupportedOperationException 异常， 也就是不支持调用；
    •  
  
  • config : NioSocketChannelConfig#NioSocketChannelConfig 中维护的信息是 NioSocketChannel 和 Socket 信息，NioServerSocketChannel.NioServerSocketChannelConfig维护的是 NioServerSocketChannel 和 ServerSocket 信息 ；
    •  
  
  • readInterestOp: NioSocketChannel 维护的值为 OP_READ， NioServerSocketChannel 维护的值为 OP_ACCEPT。
    •  
  
  • configureBlocking：两个 Channel 都设置为 false,也就是都是非阻塞IO,
    •  
  
  • unsafe: 上面我们已经分析过了，为子类提供一个 newUnsafe() 方法，NioSocketChannel 提供 NioByteUnsafe 实现，NioServerSocketChannel 提供 NioMessageUnsafe 实现；
    •  
  
  • pipeline：一样的实现，都会创建一个 DefaultChannelPipeline 实例信息；并且同样完成相关的初始化工作，包括 head,tail 节点的初始化等。
    •  
 
 
 
以上便是 NioSocketChannel 创建时会完成相关信息的初始化工作（有的是在构造器中完成初始化，有的是通过对象变量进行初始化），下面就来看看如何把 NioSocketChannel 注册到EventLoopGroup类型的 workerGroup 中的；
 
 
4、完成NioSocketChannel 到 EventLoop 的注册工作
 
 
在上面提到的 ServerBootstrap#init( channel ) 初始化Channel信息时，会提交一个任务到 channel eventLoop 中，此任务是为 当前Pipeline 添加一个 ServerBootstrapAcceptor 类型的Handler信息，也就是为 NioServerSocketChannel 的 pipeline 添加了一个 ServerBootstrapAcceptor 类型的Handler信息，而在 AbstractNioMessageChannel.NioMessageUnsafe#read() 方法中，Netty会获取 readBuffer中的信息，并调用 pipeline.fireChannelRead( Object ) 来把信息传播给 pipeline 上的handler 去执行，源码如下：
 
 
private final class NioMessageUnsafe extends AbstractNioUnsafe {

    private final List readBuf = new ArrayList();

    @Override
    public void read() {
        assert eventLoop().inEventLoop();
        final ChannelConfig config = config();
        final ChannelPipeline pipeline = pipeline();
        final RecvByteBufAllocator.Handle allocHandle = unsafe().recvBufAllocHandle();
        allocHandle.reset(config);

        boolean closed = false;
        Throwable exception = null;
        try {
            try {
                do {
                     // 根据 ACCEPT 事件获取 SocketChannel 并封装成功 NioSocketChannel 放入 readBuff 中
                    int localRead = doReadMessages(readBuf);
                    if (localRead == 0) {
                        break;
                    }
                    if (localRead < 0) {
                        closed = true;
                        break;
                    }

                    allocHandle.incMessagesRead(localRead);
                } while (allocHandle.continueReading());
            } catch (Throwable t) {
                exception = t;
            }

            int size = readBuf.size();
            for (int i = 0; i < size; i ++) {
                readPending = false;
                // 循环每一个事件信息并 传播 channelRead 方法
                pipeline.fireChannelRead(readBuf.get(i));
            }
            readBuf.clear();
            allocHandle.readComplete();
            pipeline.fireChannelReadComplete();
        } finally {
            if (!readPending && !config.isAutoRead()) {
                removeReadOp();
            }
        }
    }
}
 
 
根据上面的代码可以看出，最终会通过pipeline传播事件获取的消息，也就是NioScoketChannel 对象，因此会调用到 ServerBootstrap.ServerBootstrapAcceptor#channelRead() 方法，其对应源码如下：
 
 
@Override
@SuppressWarnings("unchecked")
public void channelRead(ChannelHandlerContext ctx, Object msg) {
    final Channel child = (Channel) msg;

    child.pipeline().addLast(childHandler);

    setChannelOptions(child, childOptions, logger);

    for (Entry, Object> e: childAttrs) {
        child.attr((AttributeKey) e.getKey()).set(e.getValue());
    }

    try {
        childGroup.register(child).addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                if (!future.isSuccess()) {
                    forceClose(child, future.cause());
                }
            }
        });
    } catch (Throwable t) {
        forceClose(child, t);
    }
}
 
 
以上channelRead(ChannelHandlerContext ctx, Object msg) 方法中，msg信息就是我们提到的 NioSocketChannel 对象，通过以上代码，其主要完成以下几个功能：
 
 
     
  
  1. 为 NioSocketChannel pipeline 添加childHandler,也就是我们在写 server端代码时调用 ServerBootstrap#childHandler(ChannelHandler)配置的 handler 信息；
    2.  
  
  2. 为 NioSocketChannel 初始化我们提供的相关配置，也是我们服务端编码时通过调用 childOption（ChannelOption childOption, T value）和 childAttr(.AttributeKey childKey, T value) 写入的配置信息；
    3.  
  
  3. 完成 NioSocketChannel 到 childGropu 中 EventLoop 的注册，具体注册逻辑，跟我们上面分析的 NioServerSocketChannel 注册到 parentGriup 中的 EventLoop 的逻辑是一样的，区别就是兴趣事件的绑定，NioSocketChannel 是在注册完 EventLoop 时便已是 active状态，所以当时就会通过 pipeline传播调用 channelActive() 并在 head 中绑定 readInterestOp （OP_READ）事件到 selector中。而 NioServerSocketChannel 则是在完成端口号的绑定后才会提交一个任务来传播 channelActive 进行 readInterestOp （OP_ACCEPT）事件绑定 。
    4.  
 
 
 
流程图
 
 
1、NioEventLoop 到 Pipeline流程图
 
 
 
  
 
   
  
   
 
  
 
  

    image-pipeline.png 
  
 
 
 
 
END其他流程图看后续有没有时间补充吧，有建议什么的随时留言我会及时回复
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Netty服务端流程源码分析（Netty4.1.25）)

        

            

                
    
                    
  • swagger访问路径
                        igotyback
swagger
                        
    Swagger2.x版本访问地址：http://{ip}:{port}/{context-path}/swagger-ui.html{ip}是你的服务器IP地址。{port}是你的应用服务端口，通常为8080。{context-path}是你的应用上下文路径，如果应用部署在根路径下，则为空。Swagger3.x版本对于Swagger3.x版本（也称为OpenAPI3）访问地址：http://{ip
    
                    
    • 
                    
  • 高级编程--XML+socket练习题
                        masa010
java开发语言
                        
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
    
                    
    • 
                    
  • linux中sdl的使用教程,sdl使用入门
                        Melissa Corvinus
linux中sdl的使用教程
                        
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
    
                    
    • 
                    
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4)
                        算法大师
华为od面试python
                        
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
    
                    
    • 
                    
  • 闲鱼鱼小铺怎么开通？鱼小铺开通需要哪些流程？
                        高省APP大九

                        
    闲鱼鱼小铺是平台推出的一个专业程度的店铺，与普通店铺相比会有更多的权益，比如说发布的商品数量从50增加到500；拥有专业的店铺数据看板与分析的功能，这对于专门在闲鱼做生意的用户来说是非常有帮助的，那么鱼小铺每个人都能开通吗？大家好，我是高省APP联合创始人蓓蓓导师，高省APP是2021年推出的电商导购平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个可省钱佣金高，能
    
                    
    • 
                    
  • ARM驱动学习之基础小知识
                        JT灬新一
ARM嵌入式arm开发学习
                        
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
    
                    
    • 
                    
  • Low Power概念介绍-Voltage Area
                        飞奔的大虎

                        
    随着智能手机，以及物联网的普及，芯片功耗的问题最近几年得到了越来越多的重视。为了实现集成电路的低功耗设计目标，我们需要在系统设计阶段就采用低功耗设计的方案。而且，随着设计流程的逐步推进，到了芯片后端设计阶段，降低芯片功耗的方法已经很少了，节省的功耗百分比也不断下降。芯片的功耗主要由静态功耗（staticleakagepower）和动态功耗(dynamicpower)构成。静态功耗主要是指电路处于等
    
                    
    • 
                    
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）
                        算法大师
华为od面试python
                        
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
    
                    
    • 
                    
  • nosql数据库技术与应用知识点
                        皆过客，揽星河
NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
                        
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
    
                    
    • 
                    
  • 下一站深圳
                        默琊

                        
    昨天已经买好3/15到深圳的机票了，原本上周还有点拖延症发作，不太积极，所以昨天就直接逼迫自己买机票，然后在订房，下周就是确认行业和把具体的面谈日程定下来。行业的选择上目前没有太大的偏好，上一份工作主要是风控和客服，客服部分也算是个小组长，有负责培训和一些案件SOP流程的制定等工作。总感觉客服这个职位的职涯发展只能是垂直的往更高的管理层走，对于横向发展似乎不容易，而鉴于做客服1年的感受，我不太喜欢
    
                    
    • 
                    
  • 网络编程基础
                        记得开心一点啊
网络
                        
    目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 「豆包Marscode体验官」 | 云端 IDE 启动 & Rust 体验
                        张风捷特烈
iderust开发语言后端
                        
    theme:cyanosis我正在参加「豆包MarsCode初体验」征文活动MarsCode可以看作一个运行在服务端的远程VSCode开发环境。对于我这种想要学习体验某些语言，但不想在电脑里装环境的人来说非常友好。本文就来介绍一下在MarsCode里，我的体验rust开发体验。一、MarsCode是什么它的本质是:提供代码助手和云端IDE服务的web网站，可通过下面的链接访问https://www
    
                    
    • 
                    
  • 网络通信流程
                        记得开心一点啊
服务器网络运维
                        
    目录♫IP地址♫子网掩码♫MAC地址♫相关设备♫ARP寻址♫网络通信流程♫IP地址我们已经知道IP地址由网络号+主机号组成，根据IP地址的不同可以有5钟划分网络号和主机号的方案：其中，各类地址的表示范围是：分类范围适用网络网络数量主机最大连接数A类0.0.0.0~127.255.255.255大型网络12616777214【(2^24)-2】B类128.0.0.0~191.255.255.255中
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • android 更改窗口的层次,浮窗开发之窗口层级
                        Ms.Bu
android更改窗口的层次
                        
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
    
                    
    • 
                    
  • 06选课支付模块之基于消息队列发送支付通知消息
                        echo 云清
学成在线javarabbitmq消息队列支付通知学成在线
                        
    消息队列发送支付通知消息需求分析订单服务作为通用服务，在订单支付成功后需要将支付结果异步通知给其他对接的微服务，微服务收到支付结果根据订单的类型去更新自己的业务数据技术方案使用消息队列进行异步通知需要保证消息的可靠性即生产端将消息成功通知到服务端：消息发送到交换机-->由交换机发送到队列-->消费者监听队列，收到消息进行处理，参考文章02-使用Docker安装RabbitMQ-CSDN博客生产者确
    
                    
    • 
                    
  • 基于STM32与Qt的自动平衡机器人：从控制到人机交互的的详细设计流程
                        极客小张
stm32qt机器人物联网人机交互毕业设计c语言
                        
    一、项目概述目标和用途本项目旨在开发一款基于STM32控制的自动平衡机器人，结合步进电机和陀螺仪传感器，实现对平衡机器人的精确控制。该机器人可以用于教育、科研、娱乐等多个领域，帮助用户了解自动控制、机器人运动学等相关知识。技术栈关键词STM32单片机步进电机陀螺仪传感器AD采集电路Qt人机界面实时数据监控二、系统架构系统架构设计本项目的系统架构设计包括以下主要组件：控制单元:STM32单片机传感器
    
                    
    • 
                    
  • 基于STM32的汽车仪表显示系统：集成CAN、UART与I2C总线设计流程
                        极客小张
stm32汽车嵌入式硬件物联网单片机c语言
                        
    一、项目概述项目目标与用途本项目旨在设计和实现一个基于STM32微控制器的汽车仪表显示系统。该系统能够实时显示汽车的速度、转速、油量等关键信息，并通过CAN总线与其他汽车控制单元进行通信。这种仪表显示系统不仅提高了驾驶的安全性和便捷性，还能为汽车提供更智能的用户体验。技术栈关键词微控制器：STM32显示技术：TFTLCD/OLED传感器：速度传感器、温度传感器、油量传感器通信协议：CAN总线、UA
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • ESP32-C3入门教程 网络篇⑩——基于esp_https_ota和MQTT实现开机主动升级和被动触发升级的OTA功能
                        小康师兄
ESP32-C3入门教程https服务器esp32OTAMQTT
                        
    文章目录一、前言二、软件流程三、部分源码四、运行演示一、前言本文基于VSCodeIDE进行编程、编译、下载、运行等操作基础入门章节请查阅：ESP32-C3入门教程基础篇①——基于VSCode构建HelloWorld教程目录大纲请查阅：ESP32-C3入门教程——导读ESP32-C3入门教程网络篇⑨——基于esp_https_ota实现史上最简单的ESP32OTA远程固件升级功能二、软件流程
    
                    
    • 
                    
  • 项目：事半功倍的法宝
                        小小效能

                        
    行动的三大流程：记录、排程和执行，也讲了易效能的4D原则以及T-step标签法。这些流程和方法能够解决我们眼前的一地鸡毛，让我们有更多时间和精力去关注更为长远的事情，完成工作、生活和人生中重要的项目。项目管理能够让我们围绕结果去做事情，达成事半功倍的效果，也就是做更少的事情，但达成更好的效果。如果我们能够不断地达成一个又一个的项目，那么我们的人生无疑会像滚雪球一样，在长坡道上面不断积累。一、项目的
    
                    
    • 
                    
  • Table列表复现框实现【勾选-搜索-再勾选】
                        ～四时春～
java开发语言elementuivue
                        
    Table列表复现框实现【勾选-搜索-再勾选】概要整体架构流程代码实现技术细节注意参考文献概要最近在开发时遇到一个问题，在进行表单渲染时，正常选中没有问题，单如果需要搜索选中时，一个是已选中的不会回填，二是在搜索的结果中进行选中，没有实现，经过排查，查找资料后实现。例如：整体架构流程具体的实现效果如下：代码实现{{scope.row.userName}}已选区{{userItem.userName
    
                    
    • 
                    
  • 【RabbitMQ 项目】服务端：数据管理模块之绑定管理
                        月夜星辉雪
rabbitmq分布式
                        
    文章目录一.编写思路二.代码实践一.编写思路定义绑定信息类交换机名称队列名称绑定关键字：交换机的路由交换算法中会用到没有是否持久化的标志，因为绑定是否持久化取决于交换机和队列是否持久化，只有它们都持久化时绑定才需要持久化。绑定就好像一根绳子，两端连接着交换机和队列，当一方不存在，它就没有存在的必要了定义绑定持久化类构造函数：如果数据库文件不存在则创建，打开数据库，创建binding_table插入
    
                    
    • 
                    
  • 《转介绍方法论》学习笔记
                        小可乐的妈妈

                        
    一、高效转介绍的流程：价值观---执行----方案一）转介绍发生的背景：1、对象：谁向谁转介绍？全员营销，人人参与。①员工的激励政策、客户的转介绍诱因制作客户画像：a信任；支付能力；意愿度；便利度（根据家长具备四个特征的个数分为四类）B性格分类C职业分类D年龄性别②执行：套路，策略，方法，流程2、诱因：为什么要转介绍？认同信任；多方共赢；传递美好；零风险承诺打动人心，超越期待。选择做教育，就是选择
    
                    
    • 
                    
  • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    
                    
    • 
                    
  • windows下python opencv ffmpeg读取摄像头实现rtsp推流 拉流
                        图像处理大大大大大牛啊
opencv实战代码讲解视觉图像项目windowspythonopencv
                        
    windows下pythonopencvffmpeg读取摄像头实现rtsp推流拉流整体流程1.下载所需文件1.1下载rtsp推流服务器1.2下载ffmpeg2.开启RTSP服务器3.opencv读取摄像头并调用ffmpeg进行推流4.opencv进行拉流5.opencv异步拉流整体流程1.下载所需文件1.1下载rtsp推流服务器下载RTSP服务器下载页面https://github.com/blu
    
                    
    • 
                    
  • Python数据分析与可视化
                        jun778895
python数据分析开发语言
                        
    Python数据分析与可视化是一个涉及数据处理、分析和以图形化方式展示数据的过程，它对于数据科学家、分析师以及任何需要从数据中提取洞察力的专业人员来说至关重要。以下将详细探讨Python在数据分析与可视化方面的应用，包括常用的库、数据处理流程、可视化技巧以及实际应用案例。一、Python数据分析与可视化的重要性数据可视化是将数据以图形或图像的形式表示出来，以便人们能够更直观地理解数据背后的信息和规
    
                    
    • 
                    
  • 效率神器来了：AI工具手把手教你快速提升工作效能
                        kkai人工智能
人工智能学习媒体aichatgpt
                        
    随着科技的进步，AI工具已经成为提升工作效率的关键手段。本文将介绍一些实用的AI工具和方法，帮助你自动化繁琐的重复性任务、优化数据管理、促进团队协作与沟通，并提升决策质量。背景：OOPAI-免费问答学习交流-GPT自动化重复性任务Zapier：Zapier可以自动化多个应用程序之间的工作流程。例如，它能自动将Gmail中的附件保存至GoogleDrive，或在你发布新文章时，自动分享至社交媒体平台
    
                    
    • 
                    
  • 信息系统安全相关概念(下)
                        YuanDaima2048
基础概念课程笔记安全
                        
    文章总览：YuanDaiMa2048博客文章总览上篇指路：信息系统安全相关概念(上)信息系统安全相关概念[下]信息系统风险评估安全风险评估信息系统等级保护网络安全法等级保护等级保护工作流程环境安全信息系统风险评估安全风险评估对信息系统整体安全态势的感知和对重大安全事件的预警，实现“事前能预防，事中能控制，事后能处理”。安全风险组成的四要素：信息系统资产（Asset）信息系统脆弱性（Vulnerab
    
                    
    • 
                                
  • ASM系列六 利用TreeApi 添加和移除类成员
                                    lijingyao8206
jvm动态代理ASM字节码技术TreeAPI
                                    
        同生成的做法一样，添加和移除类成员只要去修改fields和methods中的元素即可。这里我们拿一个简单的类做例子，下面这个Task类，我们来移除isNeedRemove方法，并且添加一个int 类型的addedField属性。 
  
package asm.core;

/**
 * Created by yunshen.ljy on 2015/6/
    
                                
    • 
                                
  • Springmvc-权限设计
                                    bee1314
springWebjsp
                                    
     
 万丈高楼平地起。 
 
权限管理对于管理系统而言已经是标配中的标配了吧，对于我等俗人更是不能免俗。同时就目前的项目状况而言，我们还不需要那么高大上的开源的解决方案，如Spring Security，Shiro。小伙伴一致决定我们还是从基本的功能迭代起来吧。 
目标：  
1.实现权限的管理（CRUD）
2.实现部门管理 （CRUD)
3.实现人员的管理 （CRUD）
4.实现部门和权限
    
                                
    • 
                                
  • 算法竞赛入门经典（第二版）第2章习题
                                    CrazyMizzz
c算法
                                    
    2.4.1 输出技巧 
#include <stdio.h> 
 
int 
main() 
{ 
 int i, n; 
 
 scanf("%d", &n); 
 for (i = 1; i <= n; i++) 
 printf("%d\n", i); 
 return 0; 
} 
 
习题2-2 水仙花数(daffodil
    
                                
    • 
                                
  • struts2中jsp自动跳转到Action
                                    麦田的设计者
jspwebxmlstruts2自动跳转
                                    
    1、在struts2的开发中，经常需要用户点击网页后就直接跳转到一个Action，执行Action里面的方法，利用mvc分层思想执行相应操作在界面上得到动态数据。毕竟用户不可能在地址栏里输入一个Action（不是专业人士） 
  
2、＜jsp:forward page="xxx.action" /＞ ，这个标签可以实现跳转，page的路径是相对地址,不同与jsp和j
    
                                
    • 
                                
  • php 操作webservice实例
                                    IT独行者
PHPwebservice
                                    
    首先大家要简单了解了何谓webservice，接下来就做两个非常简单的例子，webservice还是逃不开server端与client端。我测试的环境为：apache2.2.11 php5.2.10做这个测试之前，要确认你的php配置文件中已经将soap扩展打开，即extension=php_soap.dll; 
OK 现在我们来体验webservice 
//server端 serve
    
                                
    • 
                                
  • Windows下使用Vagrant安装linux系统
                                    _wy_
windowsvagrant
                                    
    准备工作： 
下载安装 VirtualBox ：https://www.virtualbox.org/ 
下载安装 Vagrant ：http://www.vagrantup.com/ 
下载需要使用的 box ： 
官方提供的范例：http://files.vagrantup.com/precise32.box 
还可以在 http://www.vagrantbox.es/ 
    
                                
    • 
                                
  • 更改linux的文件拥有者及用户组(chown和chgrp)
                                    无量
clinuxchgrpchown
                                    
    本文（转）  
http://blog.163.com/yanenshun@126/blog/static/128388169201203011157308/   
http://ydlmlh.iteye.com/blog/1435157   
一、基本使用：    
使用chown命令可以修改文件或目录所属的用户： 
       命令
    
                                
    • 
                                
  • linux下抓包工具
                                    矮蛋蛋
linux
                                    
    原文地址： 
http://blog.chinaunix.net/uid-23670869-id-2610683.html 
tcpdump -nn -vv -X udp port 8888 
上面命令是抓取udp包、端口为8888 
netstat -tln 命令是用来查看linux的端口使用情况 
 
13 . 列出所有的网络连接 
lsof -i 
14. 列出所有tcp 网络连接信息 
l
    
                                
    • 
                                
  • 我觉得mybatis是垃圾！：“每一个用mybatis的男纸，你伤不起”
                                    alafqq
mybatis
                                    
    最近看了  
每一个用mybatis的男纸，你伤不起 
原文地址 ：http://www.iteye.com/topic/1073938 
发表一下个人看法。欢迎大神拍砖； 
 
个人一直使用的是Ibatis框架，公司对其进行过小小的改良； 
最近换了公司，要使用新的框架。听说mybatis不错；就对其进行了部分的研究； 
 
发现多了一个mapper层；个人感觉就是个dao； 
 
 
    
                                
    • 
                                
  • 解决java数据交换之谜
                                    百合不是茶
数据交换
                                    
    交换两个数字的方法有以下三种  ，其中第一种最常用
 
  
/*
输出最小的一个数
*/
public class jiaohuan1 {

	public static void main(String[] args) {
	int a =4;
	int b = 3;
		if(a<b){
         //  第一种交换方式
		int tmep =
    
                                
    • 
                                
  • 渐变显示
                                    bijian1013
JavaScript
                                    
    <style type="text/css">
 #wxf {
  FILTER: progid:DXImageTransform.Microsoft.Gradient(GradientType=0, StartColorStr=#ffffff, EndColorStr=#97FF98);
  height: 25px;
 }
</style>
    
                                
    • 
                                
  • 探索JUnit4扩展：断言语法assertThat
                                    bijian1013
java单元测试assertThat
                                    
    一.概述 
        JUnit 设计的目的就是有效地抓住编程人员写代码的意图，然后快速检查他们的代码是否与他们的意图相匹配。 JUnit 发展至今，版本不停的翻新，但是所有版本都一致致力于解决一个问题，那就是如何发现编程人员的代码意图，并且如何使得编程人员更加容易地表达他们的代码意图。JUnit 4.4 也是为了如何能够
    
                                
    • 
                                
  • 【Gson三】Gson解析{"data":{"IM":["MSN","QQ","Gtalk"]}}
                                    bit1129
gson
                                    
       
如何把如下简单的JSON字符串反序列化为Java的POJO对象? 
{"data":{"IM":["MSN","QQ","Gtalk"]}} 
  
下面的POJO类Model无法完成正确的解析： 
  
import com.google.gson.Gson;
    
                                
    • 
                                
  • 【Kafka九】Kafka High Level API vs. Low Level API
                                    bit1129
kafka
                                    
    1. Kafka提供了两种Consumer API 
 
 High Level Consumer API 
 Low Level Consumer API(Kafka诡异的称之为Simple Consumer API，实际上非常复杂) 
 
在选用哪种Consumer API时，首先要弄清楚这两种API的工作原理，能做什么不能做什么，能做的话怎么做的以及用的时候，有哪些可能的问题 
 
    
                                
    • 
                                
  • 在nginx中集成lua脚本：添加自定义Http头，封IP等
                                    ronin47
nginx lua
                                    
    Lua是一个可以嵌入到Nginx配置文件中的动态脚本语言，从而可以在Nginx请求处理的任何阶段执行各种Lua代码。刚开始我们只是用Lua 把请求路由到后端服务器，但是它对我们架构的作用超出了我们的预期。下面就讲讲我们所做的工作。 强制搜索引擎只索引mixlr.com 
Google把子域名当作完全独立的网站，我们不希望爬虫抓取子域名的页面，降低我们的Page rank。 
location /{
    
                                
    • 
                                
  • java-归并排序
                                    bylijinnan
java
                                    
    
import java.util.Arrays;


public class MergeSort {

	
	public static void main(String[] args) {

		int[] a={20,1,3,8,5,9,4,25};
		mergeSort(a,0,a.length-1);
		System.out.println(Arrays.to
    
                                
    • 
                                
  • Netty源码学习-CompositeChannelBuffer
                                    bylijinnan
javanetty
                                    
    CompositeChannelBuffer体现了Netty的“Transparent Zero Copy” 
 
查看API（ 
http://docs.jboss.org/netty/3.2/api/org/jboss/netty/buffer/package-summary.html#package_description） 
可以看到，所谓“Transparent Zero Copy”是通
    
                                
    • 
                                
  • Android中给Activity添加返回键
                                    hotsunshine
Activity
                                    
           
// this need android:minSdkVersion="11"
 getActionBar().setDisplayHomeAsUpEnabled(true);
 
 
 
   
 @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        
    
                                
    • 
                                
  • 静态页面传参
                                    ctrain
静态
                                    
    
$(document).ready(function () {
	var request = {
		QueryString :
		function (val) {
			var uri = window.location.search;
			var re = new RegExp("" + val + "=([^&?]*)", &
    
                                
    • 
                                
  • Windows中查找某个目录下的所有文件中包含某个字符串的命令
                                    daizj
windows查找某个目录下的所有文件包含某个字符串
                                    
    findstr可以完成这个工作。 
     
[html]  
view plain 
copy       
 
 >findstr /s /i "string" *.*   
  
上面的命令表示，当前目录以及当前目录的所有子目录下的所有文件中查找"string&qu
    
                                
    • 
                                
  • 改善程序代码质量的一些技巧
                                    dcj3sjt126com
编程PHP重构
                                    
    有很多理由都能说明为什么我们应该写出清晰、可读性好的程序。最重要的一点，程序你只写一次，但以后会无数次的阅读。当你第二天回头来看你的代码 时，你就要开始阅读它了。当你把代码拿给其他人看时，他必须阅读你的代码。因此，在编写时多花一点时间，你会在阅读它时节省大量的时间。让我们看一些基本的编程技巧：    尽量保持方法简短    尽管很多人都遵
    
                                
    • 
                                
  • SharedPreferences对数据的存储
                                    dcj3sjt126com

                                    
    SharedPreferences简介：                                                   &nbs
    
                                
    • 
                                
  • linux复习笔记之bash shell (2) bash基础
                                    eksliang
bashbash shell
                                    
    转载请出自出处：
http://eksliang.iteye.com/blog/2104329  
1.影响显示结果的语系变量（locale） 
 1.1locale这个命令就是查看当前系统支持多少种语系，命令使用如下： 
[root@localhost shell]# locale
LANG=en_US.UTF-8
LC_CTYPE="en_US.UTF-8"

    
                                
    • 
                                
  • Android零碎知识总结
                                    gqdy365
android
                                    
    1、CopyOnWriteArrayList add(E) 和remove(int index)都是对新的数组进行修改和新增。所以在多线程操作时不会出现java.util.ConcurrentModificationException错误。 
所以最后得出结论：CopyOnWriteArrayList适合使用在读操作远远大于写操作的场景里，比如缓存。发生修改时候做copy，新老版本分离，保证读的高
    
                                
    • 
                                
  • HoverTree.Model.ArticleSelect类的作用
                                    hvt
Web.netC#hovertreeasp.net
                                    
    ArticleSelect类在命名空间HoverTree.Model中可以认为是文章查询条件类，用于存放查询文章时的条件，例如HvtId就是文章的id。HvtIsShow就是文章的显示属性，当为-1是，该条件不产生作用，当为0时，查询不公开显示的文章，当为1时查询公开显示的文章。HvtIsHome则为是否在首页显示。HoverTree系统源码完全开放，开发环境为Visual Studio 2013
    
                                
    • 
                                
  • PHP 判断是否使用代理 PHP Proxy Detector
                                    天梯梦
proxy
                                    
    1. php 类 
I found this class looking for something else actually but I remembered I needed some while ago something similar and I never found one. I'm sure it will help a lot of developers who try to 
    
                                
    • 
                                
  • apache的math库中的回归——regression（翻译）
                                    lvdccyb
Mathapache
                                    
    这个Math库，虽然不向weka那样专业的ML库，但是用户友好，易用。 
多元线性回归，协方差和相关性（皮尔逊和斯皮尔曼），分布测试（假设检验，t，卡方，G），统计。 
  
数学库中还包含，Cholesky，LU，SVD，QR，特征根分解，真不错。 
  
基本覆盖了：线代，统计，矩阵， 
最优化理论 
曲线拟合 
常微分方程 
遗传算法（GA）， 
还有3维的运算。。。 

    
                                
    • 
                                
  • 基础数据结构和算法十三：Undirected Graphs (2)
                                    sunwinner
Algorithm
                                    
      
Design pattern for graph processing.  
Since we consider a large number of graph-processing algorithms, our initial design goal is to decouple our implementations from the graph representation
    
                                
    • 
                                
  • 云计算平台最重要的五项技术
                                    sumapp
云计算云平台智城云
                                    
    云计算平台最重要的五项技术 
 
 
 
1、云服务器 
 
 
云服务器提供简单高效，处理能力可弹性伸缩的计算服务，支持国内领先的云计算技术和大规模分布存储技术，使您的系统更稳定、数据更安全、传输更快速、部署更灵活。 
 
 
特性 
 
机型丰富 
 
通过高性能服务器虚拟化为云服务器，提供丰富配置类型虚拟机，极大简化数据存储、数据库搭建、web服务器搭建等工作； 
 
仅需要几分钟，根据CP
    
                                
    • 
                                
  • 《京东技术解密》有奖试读获奖名单公布
                                    ITeye管理员
活动
                                    
    ITeye携手博文视点举办的12月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。  
 
 
12月试读活动回顾： 
http://webmaster.iteye.com/blog/2164754 
 
 
本次技术图书试读活动获奖名单及相应作品如下： 
 
 
一等奖（两名） 
 
 
 Microhardest：http://microhardest.ite
    
                                
    •