疯狂学习lzh
疯狂学习lzh

NioEventLoop类型解析

NioEventLoop是netty中用来执行任务、从channel中读取数据的执行者，在创建NioEventLoopGroup时，会创建多个NioEventLoop来绑定多个channel。NioEventLoop也是netty中的核心组件，理解了NioEventLoop的设计之后，理解NioEventLoopGroup就非常好理解了。

EventLoop

EventLoop接口继承了ExecutorService接口，表明这也是个线程池。当一个Channel注册完成之后，EventLoop就会处理这个channel的所有I/O操作。通常来说，一个EventLoop会处理多个Channel，但也取决于实现的细节和内部。EventLoop接口还继承了EventLoopGroup和OrderedEventExecutor两个接口，OrderedEventExecutor接口表明这个类会有序地执行被提交的任务，对于EventLoopGroup的特性则会在以后进行介绍。

NioEventLoop

NioEventLoop是SingleThreadEventLoop类的子类，实现了EventLoop。NioEventLoop将channel注册到多路复用器（selector）上并处理事件循环。
NioEventLoop中定义了一个常量SELECTOR_AUTO_REBUILD_THRESHOLD使用来解决Linux下epoll bug的，这个值在静态代码块中赋值，可以通过系统参数io.netty.selectorAutoRebuildThreshold来进行设置，默认为512：


    private static final int MIN_PREMATURE_SELECTOR_RETURNS = 3;
    private static final int SELECTOR_AUTO_REBUILD_THRESHOLD;
    
    // Workaround for JDK NIO bug.
    //
    // See:
    // - http://bugs.sun.com/view_bug.do?bug_id=6427854
    // - https://github.com/netty/netty/issues/203
    static {
        //省略部分代码

        // 设置SELECTOR_AUTO_REBUILD_THRESHOLD，当事件循环中select次数达到SELECTOR_AUTO_REBUILD_THRESHOLD这个值时，会进行rebuildSelector
        int selectorAutoRebuildThreshold = SystemPropertyUtil.getInt("io.netty.selectorAutoRebuildThreshold", 512);
        if (selectorAutoRebuildThreshold < MIN_PREMATURE_SELECTOR_RETURNS) {
            selectorAutoRebuildThreshold = 0;
        }

        SELECTOR_AUTO_REBUILD_THRESHOLD = selectorAutoRebuildThreshold;

        if (logger.isDebugEnabled()) {
            logger.debug("-Dio.netty.noKeySetOptimization: {}", DISABLE_KEY_SET_OPTIMIZATION);
            logger.debug("-Dio.netty.selectorAutoRebuildThreshold: {}", SELECTOR_AUTO_REBUILD_THRESHOLD);
        }
    }

NioEventLoop中还有有以下的非静态成员变量：

    /**
     * The NIO {@link Selector}.
     */
    private Selector selector;
    private Selector unwrappedSelector;
    private SelectedSelectionKeySet selectedKeys;

    private final SelectorProvider provider;
    
    // nextWakeupNanos is:
    //    AWAKE            when EL is awake
    //    NONE             when EL is waiting with no wakeup scheduled
    //    other value T    when EL is waiting with wakeup scheduled at time T
    private final AtomicLong nextWakeupNanos = new AtomicLong(AWAKE);

    private final SelectStrategy selectStrategy;

    private volatile int ioRatio = 50;
    private int cancelledKeys;
    private boolean needsToSelectAgain;

其中

  • selector是被包装后的多路复用器
  • unwrappedSelector是未被包装的多路复用器
  • selectedKeys是selector收集到的事件的集合，内部包含了一个SelectionKey数组
  • provider是用来获取Selector的提供者
  • nextWakeupNanos AWAKE表示这个EventLoop是活跃的，None表时当前EventLoop在等待并且没有计划中的唤醒任务，其他值T表时当前EventLoop正在等待并且会在时间T的时候被计划唤醒，这个T是一个纳秒
  • selectStrategy 是select策略的计算器，其中的calculateStrategy方法用来计算当前的策略，默认的实现类DefaultSelectStrategy的calculateStrategy方法中是先判断任务队列中是否有任务，如果没有任务就返回SelectStrategy.Select（-2），表示需要进行阻塞地去执行selector的select方法，否则就直接执行selector的selectNow方法，获取当前有多少个事件作为结果，如果calculateStrategy方法的返回值大于零，那么就是当前有多少个事件，如果小于零，-1表示重新进行一次操作，-2表示需要进行一次阻塞的select操作，-3表示需要进行一次非阻塞的select操作，NIO模型下-3是不支持的
  • ioRatio是事件循环中需要花费在I/O上的时间的比率，值在0-100之间，值越大说明任务的I/O越密集，值越小说明计算越密集
  • cancelledKeys被移除的SelectionKey的数量
  • needsToSelectAgain是否需要再次select

NioEventLoop只有一个protected修饰的构造方法：

    /**
     * 代码片段2 NioEventLoop中的唯一构造方法
     */
    NioEventLoop(NioEventLoopGroup parent, Executor executor, SelectorProvider selectorProvider,
                 SelectStrategy strategy, RejectedExecutionHandler rejectedExecutionHandler,
                 EventLoopTaskQueueFactory queueFactory) {
        super(parent, executor, false, newTaskQueue(queueFactory), newTaskQueue(queueFactory),
                rejectedExecutionHandler);
        this.provider = ObjectUtil.checkNotNull(selectorProvider, "selectorProvider");
        this.selectStrategy = ObjectUtil.checkNotNull(strategy, "selectStrategy");
        final SelectorTuple selectorTuple = openSelector();
        this.selector = selectorTuple.selector;
        this.unwrappedSelector = selectorTuple.unwrappedSelector;
    }

在构造函数中,会给provider,selectStrategy,selector,unwrappedSelector进行赋值。其中provider和selectStrategy是构造参数中的,selector和unwrappedSelector是从构造的SelectorTuple对象中获取。selectorTuple对象通过openSelecter方法创建，openSelcetor方法会调用SelectorProvider的openSelector方法创建一个Selector，在NioEventLoop的openSelector方法中还会通过反射将创建的selector对象中的selectedKeys属性和publicSelectedKeys属性使用新创建的SelectedSelectionKeySet对象进行赋值，同时也将这个对象赋值给当前NioEventLoop的selectedKeys属性。

    private SelectorTuple openSelector() {
        final Selector unwrappedSelector;
        try {
            unwrappedSelector = provider.openSelector();
        } catch (IOException e) {
            throw new ChannelException("failed to open a new selector", e);
        }
        // 省略部分代码

        Object maybeSelectorImplClass = AccessController.doPrivileged(new PrivilegedAction() {
            @Override
            public Object run() {
                try {
                    return Class.forName(
                            "sun.nio.ch.SelectorImpl",
                            false,
                            PlatformDependent.getSystemClassLoader());
                } catch (Throwable cause) {
                    return cause;
                }
            }
        });
        // 省略部分代码

        final Class selectorImplClass = (Class) maybeSelectorImplClass;
        //新建一个SelectedSelectionKeySet对象
        final SelectedSelectionKeySet selectedKeySet = new SelectedSelectionKeySet();

        Object maybeException = AccessController.doPrivileged(new PrivilegedAction() {
            @Override
            public Object run() {
                try {
                    //获取selectedKeys和publicSelectedKeys属性
                    Field selectedKeysField = selectorImplClass.getDeclaredField("selectedKeys");
                    Field publicSelectedKeysField = selectorImplClass.getDeclaredField("publicSelectedKeys");
                    //省略部分代码
                    Throwable cause = ReflectionUtil.trySetAccessible(selectedKeysField, true);
                    if (cause != null) {
                        return cause;
                    }
                    cause = ReflectionUtil.trySetAccessible(publicSelectedKeysField, true);
                    if (cause != null) {
                        return cause;
                    }
                    //通过反射设置selector的selectedKeys和publicSelectedKeys属性为刚创建的SelectedSelectionKeySet对象
                    selectedKeysField.set(unwrappedSelector, selectedKeySet);
                        .set(unwrappedSelector, selectedKeySet);
                    return null;
                } catch (NoSuchFieldException e) {
                    return e;
                } catch (IllegalAccessException e) {
                    return e;
                }
            }
        });

        if (maybeException instanceof Exception) {
            selectedKeys = null;
            Exception e = (Exception) maybeException;
            logger.trace("failed to instrument a special java.util.Set into: {}", unwrappedSelector, e);
            return new SelectorTuple(unwrappedSelector);
        }
        //设置NioEventLoop的selectedKeys属性
        selectedKeys = selectedKeySet;
        logger.trace("instrumented a special java.util.Set into: {}", unwrappedSelector);
        //使用未包装的selector构建一个包装过的selector，再用这两个对象一起构建一个SelectorTuple对象
        return new SelectorTuple(unwrappedSelector,
                                 new SelectedSelectionKeySetSelector(unwrappedSelector, selectedKeySet));
    }



NioEventLoop中最重要的方法是run方法，由于方法内容很多，因此就直接在代码中进行注释，部分非关键代码也会进行省略：


    @Override
    protected void run() {
        int selectCnt = 0;
        //这是一个死循环 也就是会一直去获取事件
        for (;;) {
            try {
                int strategy;
                try {
                    //执行策略计算器的计算策略的方法，如果hasTask方法为true，就是说队列里面有任务，那么selector会立刻执行一次select方法，得到的int结果即为strategy
                    strategy = selectStrategy.calculateStrategy(selectNowSupplier, hasTasks());
                    switch (strategy) {
                    //CONTINUE和BUSY_WAIT都不会被走到
                    case SelectStrategy.CONTINUE:
                        continue;

                    case SelectStrategy.BUSY_WAIT:
                        // fall-through to SELECT since the busy-wait is not supported with NIO
                    
                    case SelectStrategy.SELECT:
                        //走到SELECT的话，说明上面执行的hasTasks为false

                        //计算这一次执行任务的时间在多少纳秒后
                        long curDeadlineNanos = nextScheduledTaskDeadlineNanos();
                        if (curDeadlineNanos == -1L) {
                            curDeadlineNanos = NONE; // nothing on the calendar
                        }
                        //设置当前NioEventLoop下一次select操作在curDeadlineNanos纳秒，这个纳秒数是基于io.netty.util.concurrent.ScheduledFutureTask类第一次被调用时其中的静态变量START_TIME被赋的值（当时的时间System.nanosTime()）
                        nextWakeupNanos.set(curDeadlineNanos);
                        try {
                            if (!hasTasks()) {
                                //如果curDeadlineNanos是NONE或者当前时间距离curDeadlineNanos不到5微秒，selector会立刻执行select操作，否则会阻塞到deadline（curDeadlineNanos - 5微秒，然后在按毫秒取整，也就是如果是6微秒，那么会阻塞到1毫秒之后）这个时间点再去select，得到的结果就是strategy
                                strategy = select(curDeadlineNanos);
                            }
                        } finally {
                            // This update is just to help block unnecessary selector wakeups
                            // so use of lazySet is ok (no race condition)

                            //这个时候select操作已经执行了，将当前NioEventLoop设置为活跃的（从select操作的阻塞中wakeup）
                            nextWakeupNanos.lazySet(AWAKE);
                        }
                        // fall through
                    default:
                        // 如果hasTasks为true，则不会执行上面的逻辑
                } catch (IOException e) {
                   //省略异常处理
                }
                //上面的try代码块中strategy的结果就是执行一次select操作的结果，也就是事件的数量
                //select的次数加一（不管hasTasks是否哦为true都会执行一次select操作，如果是CONTINUE的话，则不会走到这里而是直接下一次循环，并且CONTINUE这个变量除了这个方法的case中也没有其他地方用到过），重置cancelledKeys和needsToSelectAgain
                // selectCnt加一 如果连续512次加一之后没有被重置为0 ，那么netty会认为进入空转了
                selectCnt++;
                cancelledKeys = 0;
                needsToSelectAgain = false;
                final int ioRatio = this.ioRatio;
                boolean ranTasks;
                if (ioRatio == 100) {
                    //如果IO比例为100就先执行processSelectedKeys，最后执行runAllTasks。processSelectedKeys方法会获取selectedKeys中的每个SelectionKey对象的attachment属性，这个属性如果是一个channel，就从channel中执行对应事件的逻辑（read，write，connect等），如果selecttedKeys为空会直接return。
                    try {
                        if (strategy > 0) {
                            processSelectedKeys();
                        }
                    } finally {
                        // Ensure we always run tasks.
                        //依次从scheduledTaskQueue中取出task并执行，最后依次从tailTask中取出task并执行
                        ranTasks = runAllTasks();
                    }
                } else if (strategy > 0) {
                    //如果IO比例小于100 且 strategy>0
                    final long ioStartTime = System.nanoTime();
                    try {
                        processSelectedKeys();
                    } finally {
                        // Ensure we always run tasks.
                        //根据io比例和io所用的时间计算出任务所需的时间
                        final long ioTime = System.nanoTime() - ioStartTime;
                        //从scheduledTaskQueue中依次取出task放入taskQueue中，如果放入失败，就讲这个task再次放入scheduledTaskQueue中病结束循环。然后依次从taskQueue中取出task，每执行64（因为执行nanosTime()方法相对昂贵）个task后会判断是否已经超出执行任务的时间，如果超出了会结束循环，最后依次将tailTasks中的task执行完
                        ranTasks = runAllTasks(ioTime * (100 - ioRatio) / ioRatio);
                    }
                } else {
                    //参数为0的话就是最多执行64个task，也就是最小的task数量就返回
                    ranTasks = runAllTasks(0); // This will run the minimum number of tasks
                }

                if (ranTasks || strategy > 0) {
                    // 如果一次select操作后有任务被执行或者selcet的结果大于0，那么selectCnt会被重置
                    if (selectCnt > MIN_PREMATURE_SELECTOR_RETURNS && logger.isDebugEnabled()) {
                        logger.debug("Selector.select() returned prematurely {} times in a row for Selector {}.",
                                selectCnt - 1, selector);
                    }
                    selectCnt = 0;
                } 
                // unexpectedSelectorWakeup会根据select的次数是否大于SELECTOR_AUTO_REBUILD_THRESHOLD，如果大于SELECTOR_AUTO_REBUILD_THRESHOLD则会进行rebuildSelector,rebuildSelector 方法会重新构造一个Seletor并将现有的channel迁移到新的Selector上
                // 这是为了处理linux下的epoll bug，nio中是通过selector轮询io事件，selector的select方法会一直阻塞或者超时，linux有时候会出现问题，有时候即使没有io事件到达或超时selector也会返回，会导致线程进入死循环从而cup load 100%，netty定义了一个selector空轮询的次数阈值SELECTOR_AUTO_REBUILD_THRESHOLD默认为512，当selectCnt超过这个值会rebuildSelector
                else if (unexpectedSelectorWakeup(selectCnt)) { // Unexpected wakeup (unusual case)
                    selectCnt = 0;
                }
            } catch (CancelledKeyException e) {
                //省略部分代码
            } catch (Throwable t) {
                handleLoopException(t);
            }
            //省略部分代码
        }
    }



SingleThreadEventLoop


SingleThreadEventLoop是一个抽象类，继承了SingleThreadEventExecutor类，同时是NioEventLoop的父类，它也实现了实现了EventLoop接口。顾名思义，SingleThreadEventLoop使用单线程处理被提交的任务。


SingThreadEventLoop中有一个成员属性tailTasks:


    private final Queue tailTasks;



tailTasks是一个存储了Runnable类型对象的一个队列，从名称也可以看出来tailTasks是尾部的任务，tailTasks中的task会在当前或者下一次时间循环中最后别执行（从上文的代码分析中也可以看出）。


提供了一个public修饰的方法executeAfterEventLoopIteration，这个方法是用来添加一个task在当前或者下一次事件循环之后执行的，因为这个方法的权限修饰符是public，所以在使用netty的时候就可以调用这个方法来添加当前或者下一次事件循环之后执行的任务。而一般情况下tailTasks是不会被使用到的。


    /**
     * Adds a task to be run once at the end of next (or current) {@code eventloop} iteration.
     *
     * @param task to be added.
     */
    @UnstableApi
    public final void executeAfterEventLoopIteration(Runnable task) {
        ObjectUtil.checkNotNull(task, "task");
        if (isShutdown()) {
            reject();
        }

        if (!tailTasks.offer(task)) {
            reject(task);
        }

        if (!(task instanceof LazyRunnable) && wakesUpForTask(task)) {
            wakeup(inEventLoop());
        }
    }



同样还提供了删除task的方法：


    /**
     * Removes a task that was added previously via {@link #executeAfterEventLoopIteration(Runnable)}.
     *
     * @param task to be removed.
     *
     * @return {@code true} if the task was removed as a result of this call.
     */
    @UnstableApi
    final boolean removeAfterEventLoopIterationTask(Runnable task) {
        return tailTasks.remove(ObjectUtil.checkNotNull(task, "task"));
    }



SingleThreadEventLoop还重写了父类SingleThreadEventExecutor的hasTasks方法，如果父类中的taskQueue不为空或自身的tailTasks不为空则会返回true：


    @Override
    protected boolean hasTasks() {
        return super.hasTasks() || !tailTasks.isEmpty();
    }



SingleThreadEventExecutor


SingleThreadEventExecutor是SingleThreadEventLoop的父类，这是一个抽象类，继承自AbstractScheduledEventExecutor，实现了OrderedEventExecutor接口（SingleThreadEventExecutor没有实现EventLoop接口，所以SingleThreadEventLoop相比SingleThreadEventExecutor而言其特点就是实现了EventLoop接口，也就是说SingleThreadEventLoop处理事件是循环去处理的，不过EventLoop接口并没有定义循环处理的方法，而只是语义上规定进行循环处理事件。因为SingleThreadEventLoop是循环的，所以SingleThreadEventLoop也就可以定于在循环的结尾执行tailTasks中的任务）。


SingleThreadEventExecutor中含有以下一些重要的成员变量:


    // 任务队列
    private final Queue taskQueue;
    // 执行任务的线程，会使用下面的executor来启动，并将thread设置为executor中执行的线程
    private volatile Thread thread;
    //线程的一些属性
    @SuppressWarnings("unused")
    private volatile ThreadProperties threadProperties;
    //执行器，用来启动
    private final Executor executor;
    //上面的thread是否被interrupte了
    private volatile boolean interrupted;
    //最大的任务数量
    private final int maxPendingTasks;
    //达到最大任务数量之后的拒绝策略
    private final RejectedExecutionHandler rejectedExecutionHandler;
    //上一次执行的时间
    private long lastExecutionTime;
    //这个SingleThreadEventExecutor执行器的状态，刚初始化的时候是未启动
    @SuppressWarnings({ "FieldMayBeFinal", "unused" })
    private volatile int state = ST_NOT_STARTED;



SingleThreadEventExecutor执行任务的方法是execute方法和lazyExecute方法，这两个方法最终都调用了另一个私有的重载的execute方法：


    @Override
    public void execute(Runnable task) {
        ObjectUtil.checkNotNull(task, "task");
        execute(task, !(task instanceof LazyRunnable) && wakesUpForTask(task));
    }

    @Override
    public void lazyExecute(Runnable task) {
        execute(ObjectUtil.checkNotNull(task, "task"), false);
    }

    private void execute(Runnable task, boolean immediate) {
        //判断当前线程是否是执行任务的线程（成员变量thread）
        boolean inEventLoop = inEventLoop();
        //将task加入任务队列中
        addTask(task);
        if (!inEventLoop) {
            // 如果当前线程不是执行任务的线程，就执行startThread方法，做这个判断是因为在执行任务的线程中也会使用execute提交任务
            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 && immediate) {
            wakeup(inEventLoop);
        }
    }



在execute(Runnable task, boolean immediate)这个方法中会调用startThread方法，下面看下startThread方法：


    private void startThread() {
        if (state == ST_NOT_STARTED) {
            //如果线程状态没有启动就会将状态设为已经启动，病执行doStartThread方法
            //如果线程已经启动了，就什么都不会做，上面的execute(Runnable task, boolean immediate)方法也仅仅只是将task放入任务队列中去
            if (STATE_UPDATER.compareAndSet(this, ST_NOT_STARTED, ST_STARTED)) {
                boolean success = false;
                try {
                    doStartThread();
                    success = true;
                } finally {
                    if (!success) {
                        //没有成功的话就将状态设为未启动
                        STATE_UPDATER.compareAndSet(this, ST_STARTED, ST_NOT_STARTED);
                    }
                }
            }
        }
    }



线程状态没有启动的话，就调用doStartThread方法，通常来说doStratThread方法只会被调用一次：


    private void doStartThread() {
        assert thread == null;
        // 通过executor这个线程池来执行一个Runnable对象，这个线程池中执行这个Runnable的线程就是工作线程
        executor.execute(new Runnable() {
            @Override
            public void run() {
                //将成员变量thread设置为当前线程
                thread = Thread.currentThread();
                if (interrupted) {
                    thread.interrupt();
                }

                boolean success = false;
                updateLastExecutionTime();
                try {
                    //这里最终会调用子类中的run方法，在NioEventLoop中就是循环select获取事件，并执行任务，可参考上文介绍的NioEventLoop中run方法
                    SingleThreadEventExecutor.this.run();
                    success = true;
                } catch (Throwable t) {
                    logger.warn("Unexpected exception from an event executor: ", t);
                } finally {
                    //省略部分代码
                }
            }
        });
    }



根据以上的代码可以发现，当使用NioEventloop执行任务时，会将任务先放在队列中，如果是第一次启动，会先启动线程，在这个线程中会不断地循环获取事件封装任务放入队列中，并从中任务队列中获取任务执行。这就是NioEventLoop的执行的一系列流程。


AbstractScheduledEventExecutor


AbstractScheduledEventExecutor是一个抽象类，是SingleThreadEventExecutor的父类，是一个支持定时任务的执行器。AbstractScheduledEventExecutor中维护了一个优先队列scheduledTaskQueue用来存放定时任务，以及一个long类型的nextTaskId表示下一个定时任务的id：


    PriorityQueue> scheduledTaskQueue;
    long nextTaskId;



scheduledTaskQueue中存放的类型为ScheduledFutureTask


上面NioEventLoop的run方法中中调用nextScheduledTaskDeadlineNanos方法来获取下一个定时任务的时间作为select操作的超时时间，其定义如下：


    /**
     * Return the deadline (in nanoseconds) when the next scheduled task is ready to be run or {@code -1}
     * if no task is scheduled.
     */
    protected final long nextScheduledTaskDeadlineNanos() {
        //获取下一次定时任务
        ScheduledFutureTask scheduledTask = peekScheduledTask();
        //返回下一次定时任务的deadlineNanos
        return scheduledTask != null ? scheduledTask.deadlineNanos() : -1;
    }



AbstractScheduledEventExecutor主要是实现了父类中定义的一些schedule方法：


    @Override
    public ScheduledFuture schedule(Runnable command, long delay, TimeUnit unit) {
        ObjectUtil.checkNotNull(command, "command");
        ObjectUtil.checkNotNull(unit, "unit");
        if (delay < 0) {
            delay = 0;
        }
        validateScheduled0(delay, unit);

        return schedule(new ScheduledFutureTask(
                this,
                command,
                deadlineNanos(unit.toNanos(delay))));
    }

    @Override
    public  ScheduledFuture schedule(Callable callable, long delay, TimeUnit unit) {
        ObjectUtil.checkNotNull(callable, "callable");
        ObjectUtil.checkNotNull(unit, "unit");
        if (delay < 0) {
            delay = 0;
        }
        validateScheduled0(delay, unit);

        return schedule(new ScheduledFutureTask(this, callable, deadlineNanos(unit.toNanos(delay))));
    }

    @Override
    public ScheduledFuture scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {
        ObjectUtil.checkNotNull(command, "command");
        ObjectUtil.checkNotNull(unit, "unit");
        if (initialDelay < 0) {
            throw new IllegalArgumentException(
                    String.format("initialDelay: %d (expected: >= 0)", initialDelay));
        }
        if (period <= 0) {
            throw new IllegalArgumentException(
                    String.format("period: %d (expected: > 0)", period));
        }
        validateScheduled0(initialDelay, unit);
        validateScheduled0(period, unit);

        return schedule(new ScheduledFutureTask(
                this, command, deadlineNanos(unit.toNanos(initialDelay)), unit.toNanos(period)));
    }

    @Override
    public ScheduledFuture scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) {
        ObjectUtil.checkNotNull(command, "command");
        ObjectUtil.checkNotNull(unit, "unit");
        if (initialDelay < 0) {
            throw new IllegalArgumentException(
                    String.format("initialDelay: %d (expected: >= 0)", initialDelay));
        }
        if (delay <= 0) {
            throw new IllegalArgumentException(
                    String.format("delay: %d (expected: > 0)", delay));
        }

        validateScheduled0(initialDelay, unit);
        validateScheduled0(delay, unit);

        return schedule(new ScheduledFutureTask(
                this, command, deadlineNanos(unit.toNanos(initialDelay)), -unit.toNanos(delay)));
    }



这些方法都最终构造一个ScheduledFutureTask对象，并且调用private修饰的schedule(final ScheduledFutureTask task)方法：


    private  ScheduledFuture schedule(final ScheduledFutureTask task) {
        if (inEventLoop()) {
            scheduleFromEventLoop(task);
        } else {
            final long deadlineNanos = task.deadlineNanos();
            // task will add itself to scheduled task queue when run if not expired
            if (beforeScheduledTaskSubmitted(deadlineNanos)) {
                execute(task);
            } else {
                lazyExecute(task);
                // Second hook after scheduling to facilitate race-avoidance
                if (afterScheduledTaskSubmitted(deadlineNanos)) {
                    execute(WAKEUP_TASK);
                }
            }
        }

        return task;
    }



在schedule(final ScheduledFutureTask task)方法中会将这个ScheduledFutureTask对象执行execute方法，execute方法依赖于子类的实现，可以参照上文中SingleThreadEventExecutor中的实现。ScheduledFutureTask类实现了Runable接口，并且其中有以下两个成员变量：


    private long deadlineNanos;
    /* 0 - no repeat, >0 - repeat at fixed rate, <0 - repeat with fixed delay */
    private final long periodNanos;



    

  • deadlineNanos，task的截止时间（纳秒）
    • 

  • periodNanos，任务循环的时间段（纳秒），如果等于0则不循环，如果大于定则按照固定的频率循环，如果小于0则按照固定的延迟循环（固定频率下一次执行的时间是执行前的时间加上时间段的时长，固定延迟是执行完之后的时间加上时间段的时长）
     ScheduledFutureTask父类中还有EventExecutor类型的executor和Runnable类型的task两个成员变量，分别是执行任务的执行器和需要被定时执行的任务本身。
    • 



ScheduledFutureTask 的run方法中体现了是如何实现循环的：


    public void run() {
        assert executor().inEventLoop();
        try {
            if (delayNanos() > 0L) {
                // Not yet expired, need to add or remove from queue
                if (isCancelled()) {
                    scheduledExecutor().scheduledTaskQueue().removeTyped(this);
                } else {
                    scheduledExecutor().scheduleFromEventLoop(this);
                }
                return;
            }
            //不循环，直接调用runTask，runTask方法会执行task中的run方法
            if (periodNanos == 0) {
                if (setUncancellableInternal()) {
                    V result = runTask();
                    setSuccessInternal(result);
                }
            } else {
                // check if is done as it may was cancelled
                if (!isCancelled()) {
                    //执行task
                    runTask();
                    if (!executor().isShutdown()) {
                        if (periodNanos > 0) {
                            //如果按照固定频率，那么这次循环的deadline加上时间段的时长就是下次循环的deadline
                            deadlineNanos += periodNanos;
                        } else {
                            //如果按照固定延迟，就是现在的时间加上时间段的时长，因为这边periodNanos是小于0的，所以这里是减去
                            deadlineNanos = nanoTime() - periodNanos;
                        }
                        //最后因为要循环执行，所以在这里再次将this对象添加到taskQueue中
                        if (!isCancelled()) {
                            scheduledExecutor().scheduledTaskQueue().add(this);
                        }
                    }
                }
            }
        } catch (Throwable cause) {
            setFailureInternal(cause);
        }
    }



ScheduledFutureTask类型的对象本身就是用来作为任务被执行，ScheduledFutureTask中也包含了一个定时执行的任务（都是Runnable对象）。不管是定时的还是非定时的任务都会放在taskQueue中，它们的run方法都是在NioEventLoop的run方法中调用runAllTasks时循环获取taskQueue中的任务然后被调用。
























你可能感兴趣的:(NioEventLoop类型解析)






    

  • 数据结构奇妙旅程之深入解析快速排序
山间漫步人生路
数据结构排序算法算法

    快速排序（QuickSort）是一种高效的排序算法，它使用了分治法的策略来将一个数组排序。其基本思想是选择一个基准元素，通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有数据都比基准元素小，另一部分的所有数据都比基准元素大，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。工作原理选择基准：从待排序的序列中选一个元素作为基准（pivo
    

    • 

  • 华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++）
华为OD题库
华为od链表java

    须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
    

    • 

  • 2022-10-02
朗月斋主

    肿瘤溶解病毒（OVs）作为一种新型的免疫治疗和治疗辅助剂，在制药行业中越来越受到关注，因为它们能够通过多种机制诱导和提高抗肿瘤免疫力。首先，OVs能够利用宿主免疫系统的内在机制（例如，逃避免疫检测）可以使肿瘤的免疫逃逸机制失效。第二，许多类型的OVs已被证明可以直接裂解肿瘤细胞，从而诱导出由肿瘤相关抗原和危险信号分子释放介导的肿瘤特异性T细胞反应。第三，表达免疫刺激治疗基因的武装OV可以在肿瘤组织
    

    • 

  • c++中如何判断变量的数据类型，并输出
xnrbjy
c++开发语言

    C++中如果想要判断变量的数据类型，可以使用typeid运算符。该运算符返回一个std::type_info类型的对象，可以使用name()方法获取其名称从而确定变量的类型，例如：#include#includeusingnamespacestd;intmain(){inta=123;floatb=3.14;boolc=true;chard='A';stringe="HelloWorld";cou
    

    • 

  • 标定系列——基于OpenCV实现普通相机、鱼眼相机不同标定板下的标定（五）
JANGHIGH
标定opencv

    标定系列——基于OpenCV实现相机标定（五）说明代码解析VID5.xmlin_VID5.xmlcamera_calibration.cpp说明该程序可以实现多种标定板的相机标定工作代码解析VID5.xmlimages/CameraCalibration/VID5/xx1.jpgimages/CameraCalibration/VID5/xx2.jpgimages/CameraCalibratio
    

    • 

  • docker怎么端口映射
Lance_mu
docker容器运维

    1、默认固定的端口#Web服务器：WebApache或Nginx通常使用80端口HTTP：80HTTPS：443#数据库服务器MySQL：3306PostgreSQL：5432MongoDB：27017Redis：6379#邮件服务器SMTP：25POP3：110IMAP：143#其他服务SSH：22FTP：21DNS（域名解析）：53代理服务器Squid：3128版本控制系统Git：9418(S
    

    • 

  • Golang标准库fmt深入解析与应用技巧
walkskyer
golang标准库golangjava数据库

    Golang标准库fmt深入解析与应用技巧前言fmt包的基本使用打印与格式化输出函数Print系列函数格式化字符串格式化输入函数小结字符串格式化基本类型的格式化输出自定义类型的格式化输出控制格式化输出的宽度和精度小结错误处理与fmt使用fmt.Errorf生成错误信息fmt包与错误处理的最佳实践小结日志记录与fmtfmt包在日志记录中的应用结合log包使用fmt进行高级日志处理小结fmt与IOfm
    

    • 

  • 倒贴服传奇在什么平台下载 2024最火的倒贴服传奇平台排行榜
诸葛村夫一游戏频道

    2024游戏盒子网站排行榜大全随着数位科技的发展，2024年手游市场持续火爆，各种新开手游持续涌现。本文为广大手游爱好者带来巅峰推荐，总结五个最具实力的手游新服发布网站，为您提供最全面的游戏资讯以及专业的游戏攻略。▶2024最火的倒贴服传奇平台排行榜TOP1：游戏豹官网特点：内部特权游戏类型：多类型推荐日活跃人数：15万网址链接：www.ystt88.cn游戏介绍：游戏豹官网以快速获取新开手游的特
    

    • 

  • 剧本杀【幕后玩家】复盘解析+凶手是谁+剧透结局+测评+怎么玩？
VX搜_彤彤速递

    每天持续更新复盘有15000＋：线下剧本杀·百变大侦探·我是谜·谁是凶手·玩吧·剧本杀线上·戏精大侦探·魔王杀·儿童剧本杀...所有谜题在等着你去揭开。为了你获得更好的游戏体验，本文仅显示《幕后玩家》剧本杀部分真相复盘，获取完整真相复盘只需两步①【微信关注公众号：云云复盘】②回复【幕后玩家】即可查看获取哦贾友仁利用自己保险公司的职务，在杨光审车时，隐瞒了车子存在刹车不灵的问题。想让杜若出车祸死亡，
    

    • 

  • 【奶茶剧本杀】玩吧《梨园醉》剧本杀凶手是谁剧透+真相答案复盘解析攻略
VX搜_奶茶剧本杀

    本文为玩吧剧本杀《梨园醉》剧本杀测评+部分真相复盘，获取完整真相复盘只需两步：①、关注微信公众号【奶茶剧本杀】→②、回复玩吧剧本杀《梨园醉》即可获取查看玩吧剧本杀《梨园醉》剧本杀真相答案复盘+凶手剧透：以下是玩家评测+部分关键证据，凶手，时间线，复盘解析，推理逻辑--------------------------------------------------------------------
    

    • 

  • [数据集][图像分类]河道污染分类数据集1923张4类别
FL1623863129
数据集分类数据挖掘人工智能

    数据集类型：图像分类用，不可用于目标检测无标注文件数据集格式：仅仅包含jpg图片，每个类别文件夹下面存放着对应图片图片数量(jpg文件个数)：1922分类类别数：4类别名称:["lianghao","qingwei","yanzhong","zhongdu"]每个类别图片数：lianghao图片数：435qingwei图片数：423yanzhong图片数：577zhongdu图片数：487重要说明
    

    • 

  • python转码
Desamond
python开发语言

    转码在许多场景中都有应用，以下是一些常见的场景：网页开发：当用户在网页上输入文本时，可能需要将特殊字符（如空格、引号、特殊符号等）进行转码，以防止这些字符对URL或HTML代码产生干扰。文件名处理：在处理文件名时，可能需要将特殊字符进行转码，以避免文件名被错误地解析或显示。数据传输：在数据传输过程中，为了确保数据的完整性和正确性，可能需要将数据中的特殊字符进行转码。数据存储：在数据库或数据存储中，
    

    • 

  • 27.Python从入门到精通—Python异常处理 抛出异常 用户自定义异常 定义清理行为 预定义的清理行为
以山河作礼。
#Python基础入门—详解版pythonjava服务器

    27.从入门到精通：Python异常处理抛出异常用户自定义异常定义清理行为预定义的清理行为异常处理抛出异常用户自定义异常定义清理行为预定义的清理行为异常处理在Python中，异常处理是一种处理程序在执行期间可能遇到的错误的方法。当Python解释器遇到错误时，它会引发异常。异常是一种Python对象，它包含有关错误的信息，例如错误类型和错误位置。为了处理异常，您可以使用try-except语句。在
    

    • 

  • 风险管理和采购管理核心考点梳理
WorkLee
PMPPMP风险管理采购管理

    个人总结，仅供参考，欢迎加好友一起讨论PMP-风险管理和采购管理核心考点梳理风险管理风险是一个中性词，包括机会和威胁。风险管理的子过程非常多，但是相对来说子过程之间的逻辑非常清晰，整个风险管理的过程都是在维护一个非常重要的工件-风险登记册。风险管理是项目管理全生命周期都要开展的。1）规划风险管理风险管理计划包含哪些内容？解析：风险管理计划是描述如何安排与实施风险管理活动。（风险管理计划中无风险）包
    

    • 

  • 沟通管理和相关方管理核心考点梳理
WorkLee
PMPPMP沟通管理相关方干系人

    个人总结，仅供参考，欢迎加好友一起讨论PMP-沟通管理和相关方管理核心考点梳理沟通管理和相关方（干系人）管理这两章放在一起进行梳理，这两章很多的考点很容易混淆，经常会纠结于一些题目，究竟选择沟通管理还是干系人管理的知识点。沟通管理1）规划沟通管理沟通在PMP中是指信息流的传递，PM是根据谁的需求来确定这种信息流的传递方式、频率，内容、格式呢？解析：规划沟通管理是基于每个相关方或相关方群体的信息需求
    

    • 

  • 2022-07-09
双髻山府正堂

    【解析】法律解释是指一定的人或组织对法律规定意义的说明与阐述。法律解释由于解释主体和解释效力的不同可以分为正式解释与非正式解释。所谓正式解释，通常也叫法定解释，是指由特定的国家机关、官员或其他有解释权的人对法律作出的具有法律上约束力的解释。由于王某老伴与子女对该条的解释不具有法律上的约束力，故为非正式解释，A项说法错误。主观目的解释是指根据参与立法的人的意志或立法资料揭示某个法律规定的含义，或者说
    

    • 

  • Python | Redis工具类
-拟墨画扇-
Pythonredis数据库缓存python

    一、需求自动连接Redis数据库，通过连接池处理数据对输出结果进行Log打印并保存到文件二、代码Utils.redisUtils.py#!/usr/bin/envpython#-*-coding:utf-8-*-importredisfromUtils.loggerimportlog"""Redis数据格式(1)字符串|存储形式:key-value:str-存储二进制数据:可以存储任意类型的数据，
    

    • 

  • 如果有时间
哆哆的小主人

    文／哆哆的小主人自述类型。听歌有感。《漠河舞厅》“如果有时间，你会来看一看我吧。”日历上勾勾画画太多痕迹，早已看不清本来面貌，也就数不清，距离他离开，究竟已经过了多少天。也许已经过了上千天了吧，但脑海里关于分别那天的场景却尤为清晰，没有爆发激烈的争执，也没有因为什么而导致关系破裂，只是好像两个人都突然在心里默认了，到了该分开的时候。那天的所有好像都一如往常，甚至看起来比往常还要甜蜜。并肩散步走到了
    

    • 

  • Numpy、Pandas库的使用
貮叁
量化投资分析pythonpython数据分析

    目录Numpy1、概述2、基础操作2.1生成一个numpy的array数组：2.2自定义一个新的数据类型：np.dtype()3、并行化思想4、量化分析应用4.1索引选取和切片选择4.2数据转换与规整4.3逻辑条件进行数据筛选4.4通用序列函数4.5文件保存与读取Pandas1、简介2、Series和DataFrame的使用2.1Series2.2DataFrame3、量化分析应用3.1形成一个p
    

    • 

  • 项目管理工具最佳实践
水岩

    各个公司的最佳实践去哪儿jira自定义使用1.jira编号对应git分支命名，后台增加监控程序，新增一个分支，自动解析分支中的jira编号，自动落地到数据库，完成映射2.各个发布系统间信息同步，消息中心（IC）+数据中心（DC）,广播消息加一站式查询，持续集成，推进代码检查质量，分钟级反馈质量检查反思：1.项目管好：针对一线研发人员，简单易用，而不是满足管理层的“统计度量”（...）简化分类字段，
    

    • 

  • java实体中返回前端的double类型四舍五入（格式化）
婲落ヽ紅顏誶
java

    根据业务，需要通过后端给前端返回部分double类型的数值，一般需要保留两位小数，使用jackson转换对象packagecom.ruoyi.common.core.config;importcom.fasterxml.jackson.core.JsonGenerator;importcom.fasterxml.jackson.databind.JsonSerializer;importcom.f
    

    • 

  • UNDERSTANDING HTML WITH LARGE LANGUAGE MODELS
liferecords
LLM语言模型人工智能自然语言处理

    UNDERSTANDINGHTMLWITHLARGELANGUAGEMODELS相关链接：arXiv关键字：大型语言模型、HTML理解、Web自动化、自然语言处理、机器学习摘要大型语言模型（LLMs）在各种自然语言任务上表现出色。然而，它们在HTML理解方面的能力——即解析网页的原始HTML，对于自动化基于Web的任务、爬取和浏览器辅助检索等应用——尚未被充分探索。我们为HTML理解模型（经过微调
    

    • 

  • stm32之GPIO寄存器
luofengmacheng
嵌入式stm32嵌入式硬件单片机

    文章目录1背景2GPIO寄存器的类型2.1端口配置寄存器2.2设置/清除寄存器和位清除寄存器3总结1背景C51单片机在进行数据的输入输出时，是直接操作与外部引脚关联的内部寄存器，例如，当设置P2_1为0时，就是将外部引脚的P21引脚设置为低电平，当读取P2_1时，就是读取P21的电平。与之类似，stm32芯片内部也有很多用于输入输出的寄存器，这些寄存器也是用于操作外部引脚，但是比C51单片机复杂很
    

    • 

  • Azkaban各种类型的Job编写
__元昊__

    一、概述原生的Azkaban支持的plugin类型有以下这些：command：Linuxshell命令行任务gobblin：通用数据采集工具hadoopJava：运行hadoopMR任务java：原生java任务hive：支持执行hiveSQLpig：pig脚本任务spark：spark任务hdfsToTeradata：把数据从hdfs导入TeradatateradataToHdfs：把数据从Te
    

    • 

  • Python极速入门：五分钟开启实战之旅！
知白守黑V
Python编程语言系统运维python编程语言python开发python学习python入门python数据分析

    1.Python基础语法和结构：了解Python的基本语法，包括变量、数据类型、运算符、注释等。控制流：掌握条件语句（if-elif-else）、循环（for和while）及其控制（break和continue）。函数：学习如何定义和使用函数，包括参数传递、返回值、作用域和闭包。模块和包：理解如何导入和使用模块，以及如何创建和使用自己的包。2.数据处理列表、元组和集合：学习这些序列类型的操作和方法
    

    • 

  • java基础相关面试题详细总结
。。。。。96
java开发语言

    1.Java中的数据类型有哪些？答：Java中的数据类型包括基本数据类型（如整数、浮点数、字符等）和引用数据类型（如类、接口、数组等）。2.什么是面向对象编程（OOP）？答：面向对象编程是一种编程范式，它将数据和对数据的操作封装在一起，形成对象。通过对象之间的交互来实现程序的功能。3.解释类和对象的关系。答：类是对象的抽象描述，而对象是类的具体实例。一个类可以创建多个对象，每个对象都具有类中定义的
    

    • 

  • 电商打单ERP必备API列表-API调用指南
懂电商API接口的Jennifer
淘宝API接口springjava后端爬虫数据挖掘网络爬虫

    1、打开淘宝开放平台API文档，查看API参数。2、选择需要的API，进行测试对接。注册账号获取APIkey3、进入API测试页，开始测试taobao.customcustom-自定义API操作公共参数名称类型必须描述keyString是调用key（必须以GET方式拼接在URL中）secretString是调用密钥api_nameString是API接口名称（包括在请求地址中）[item_sear
    

    • 

  • 计算机常用端口号
王依硕
linux服务器ssh

    ftp：（20端口）用于ftp服务，用于数据传输。ftp：（21端口）用于文件上传和下载。ssh：（22端口）用于安全Shell访问和文件传输。telnet：（23端口）用于远程命令行计算机管理。smtp：（25端口）用于发送电子邮件。dns：（53端口）用于域名解析。dhcp：（67和68端口）用于动态分配IP地址和配置网络参数。tftp：（69端口）使用udp连接。finger：（79端口）是
    

    • 

  • Kotlin非常用关键字使用记录
Developings
kotlin开发语言android

    1，typealias声明一个类型别名。样例：typealiasMyBean=ItemBeandataclassItemBean(valtitle:String,valintent:Intent)valbean=MyBean("11",Intent())实现了将ItemBean数据模型取了一个别名MyBean，后续我们可以像使用别名一样使用他们2，crossinline禁止传递给内联函数的lamb
    

    • 

  • 数据库的魅力：深入探索与应用
小黄编程快乐屋
数据库

    数据库的魅力：深入探索与应用在数字化时代，数据库已经成为信息处理和存储的基石。无论是大型企业还是个人开发者，数据库都是不可或缺的工具。本文将带您深入探索数据库的魅力，了解其基本概念、类型以及应用，并分享一些实用的数据库管理技巧。一、数据库的基本概念数据库，简而言之，就是按照一定规则存储、组织和管理数据的仓库。它可以看作是一个电子化的文件柜，用于存储电子化的文件。这些文件按照特定的数据模型组织起来，
    

    • 

  • 面向对象面向过程
3213213333332132
java

    面向对象：把要完成的一件事，通过对象间的协作实现。
面向过程：把要完成的一件事，通过循序依次调用各个模块实现。
我把大象装进冰箱这件事为例，用面向对象和面向过程实现，都是用java代码完成。
1、面向对象
package bigDemo.ObjectOriented;
/**
* 大象类
*
* @Description
* @author FuJian
    

    • 

  • Java Hotspot: Remove the Permanent Generation
bookjovi
HotSpot

     
openjdk上关于hotspot将移除永久带的描述非常详细，http://openjdk.java.net/jeps/122
 
JEP 122: Remove the Permanent Generation
Author Jon Masamitsu
Organization Oracle
Created 2010/8/15
Updated 2011/
    

    • 

  • 正则表达式向前查找向后查找,环绕或零宽断言
dcj3sjt126com
正则表达式

    向前查找和向后查找
1. 向前查找：根据要匹配的字符序列后面存在一个特定的字符序列(肯定式向前查找)或不存在一个特定的序列(否定式向前查找)来决定是否匹配。.NET将向前查找称之为零宽度向前查找断言。
    对于向前查找，出现在指定项之后的字符序列不会被正则表达式引擎返回。
2. 向后查找：一个要匹配的字符序列前面有或者没有指定的
    

    • 

  • BaseDao
171815164
seda

    
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
public class BaseDao {
public Conn
    

    • 

  • Ant标签详解--Java命令
g21121
Java命令

            这一篇主要介绍与java相关标签的使用         终于开始重头戏了，Java部分是我们关注的重点也是项目中用处最多的部分。          
1
    

    • 

  • [简单]代码片段_电梯数字排列
53873039oycg
代码

           今天看电梯数字排列是9 18 26这样呈倒N排列的,写了个类似的打印例子，如下:      
import java.util.Arrays;
public class 电梯数字排列_S3_Test {
public static void main(S
    

    • 

  • Hessian原理
云端月影
hessian原理

    Hessian 原理分析
一．      远程通讯协议的基本原理
网络通信需要做的就是将流从一台计算机传输到另外一台计算机，基于传输协议和网络 IO 来实现，其中传输协议比较出名的有 http 、 tcp 、 udp 等等， http 、 tcp 、 udp 都是在基于 Socket 概念上为某类应用场景而扩展出的传输协
    

    • 

  • 区分Activity的四种加载模式----以及Intent的setFlags
aijuans
android

     
在多Activity开发中，有可能是自己应用之间的Activity跳转，或者夹带其他应用的可复用Activity。可能会希望跳转到原来某个Activity实例，而不是产生大量重复的Activity。
这需要为Activity配置特定的加载模式，而不是使用默认的加载模式。 加载模式分类及在哪里配置
Activity有四种加载模式：
standard
singleTop
    

    • 

  • hibernate几个核心API及其查询分析
antonyup_2006
html.netHibernatexml配置管理

    (一)  org.hibernate.cfg.Configuration类
        读取配置文件并创建唯一的SessionFactory对象.(一般,程序初始化hibernate时创建.)
        Configuration co
    

    • 

  • PL/SQL的流程控制
百合不是茶
oraclePL/SQL编程循环控制

    PL/SQL也是一门高级语言,所以流程控制是必须要有的,oracle数据库的pl/sql比sqlserver数据库要难,很多pl/sql中有的sqlserver里面没有
 
流程控制;
分支语句 if 条件 then 结果 else 结果 end if ;
条件语句 case when 条件 then 结果;
循环语句 loop 
    

    • 

  • 强大的Mockito测试框架
bijian1013
mockito单元测试

    一.自动生成Mock类        在需要Mock的属性上标记@Mock注解，然后@RunWith中配置Mockito的TestRunner或者在setUp()方法中显示调用MockitoAnnotations.initMocks(this);生成Mock类即可。二.自动注入Mock类到被测试类  &nbs
    

    • 

  • 精通Oracle10编程SQL(11)开发子程序
bijian1013
oracle数据库plsql

    /*
*开发子程序
*/
--子程序目是指被命名的PL/SQL块，这种块可以带有参数，可以在不同应用程序中多次调用
--PL/SQL有两种类型的子程序：过程和函数
--开发过程
--建立过程：不带任何参数
CREATE OR REPLACE PROCEDURE out_time
IS
BEGIN
DBMS_OUTPUT.put_line(systimestamp);
E
    

    • 

  • 【EhCache一】EhCache版Hello World
bit1129
Hello world

    本篇是EhCache系列的第一篇，总体介绍使用EhCache缓存进行CRUD的API的基本使用，更细节的内容包括EhCache源代码和设计、实现原理在接下来的文章中进行介绍
  环境准备
1.新建Maven项目
 
2.添加EhCache的Maven依赖
<dependency>
<groupId>ne
    

    • 

  • 学习EJB3基础知识笔记
白糖_
beanHibernatejbosswebserviceejb

    最近项目进入系统测试阶段，全赖袁大虾领导有力，保持一周零bug记录，这也让自己腾出不少时间补充知识。花了两天时间把“传智播客EJB3.0”看完了，EJB基本的知识也有些了解，在这记录下EJB的部分知识，以供自己以后复习使用。
 
EJB是sun的服务器端组件模型，最大的用处是部署分布式应用程序。EJB (Enterprise JavaBean)是J2EE的一部分，定义了一个用于开发基
    

    • 

  • angular.bootstrap
boyitech
AngularJSAngularJS APIangular中文api

    angular.bootstrap
描述：
    手动初始化angular。
    这个函数会自动检测创建的module有没有被加载多次，如果有则会在浏览器的控制台打出警告日志，并且不会再次加载。这样可以避免在程序运行过程中许多奇怪的问题发生。
  使用方法：     angular .
    

    • 

  • java-谷歌面试题-给定一个固定长度的数组，将递增整数序列写入这个数组。当写到数组尾部时，返回数组开始重新写，并覆盖先前写过的数
bylijinnan
java

    
public class SearchInShiftedArray {
/**
* 题目：给定一个固定长度的数组，将递增整数序列写入这个数组。当写到数组尾部时，返回数组开始重新写，并覆盖先前写过的数。
* 请在这个特殊数组中找出给定的整数。
* 解答：
* 其实就是“旋转数组”。旋转数组的最小元素见http://bylijinnan.iteye.com/bl
    

    • 

  • 天使还是魔鬼？都是我们制造
ducklsl
生活教育情感

    ----------------------------剧透请原谅，有兴趣的朋友可以自己看看电影，互相讨论哦！！！
    从厦门回来的动车上，无意中瞟到了书中推荐的几部关于儿童的电影。当然，这几部电影可能会另大家失望，并不是类似小鬼当家的电影，而是关于“坏小孩”的电影！
    自己挑了两部先看了看，但是发现看完之后，心里久久不能平
    

    • 

  • [机器智能与生物]研究生物智能的问题
comsci
生物

    
      我想,人的神经网络和苍蝇的神经网络,并没有本质的区别...就是大规模拓扑系统和中小规模拓扑分析的区别....
      但是,如果去研究活体人类的神经网络和脑系统,可能会受到一些法律和道德方面的限制,而且研究结果也不一定可靠,那么希望从事生物神经网络研究的朋友,不如把
    

    • 

  • 获取Android Device的信息
dai_lm
android

    
String phoneInfo = "PRODUCT: " + android.os.Build.PRODUCT;
phoneInfo += ", CPU_ABI: " + android.os.Build.CPU_ABI;
phoneInfo += ", TAGS: " + android.os.Build.TAGS;
ph
    

    • 

  • 最佳字符串匹配算法（Damerau-Levenshtein距离算法）的Java实现
datamachine
java算法字符串匹配

    原文：http://www.javacodegeeks.com/2013/11/java-implementation-of-optimal-string-alignment.html------------------------------------------------------------------------------------------------------------
    

    • 

  • 小学5年级英语单词背诵第一课
dcj3sjt126com
englishword

    long 长的
show 给...看，出示
mouth 口，嘴
write 写
 
use 用，使用
take 拿，带来
hand 手
clever 聪明的
 
often 经常
wash 洗
slow 慢的
house 房子
 
water 水
clean 清洁的
supper 晚餐
out 在外
 
face 脸，
    

    • 

  • macvim的使用实战
dcj3sjt126com
macvim

    macvim用的是mac里面的vim, 只不过是一个GUI的APP, 相当于一个壳
 
1. 下载macvim
https://code.google.com/p/macvim/
 
2. 了解macvim
:h               vim的使用帮助信息
:h macvim  
    

    • 

  • java二分法查找
蕃薯耀
java二分法查找二分法java二分法

    java二分法查找
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
蕃薯耀 2015年6月23日 11:40:03 星期二
http:/
    

    • 

  • Spring Cache注解+Memcached
hanqunfeng
springmemcached

    Spring3.1 Cache注解 
依赖jar包：
<!-- simple-spring-memcached -->
<dependency>
<groupId>com.google.code.simple-spring-memcached</groupId>
<artifactId>simple-s
    

    • 

  • apache commons io包快速入门
jackyrong
apache commons

    原文参考
http://www.javacodegeeks.com/2014/10/apache-commons-io-tutorial.html
  Apache Commons IO 包绝对是好东西，地址在http://commons.apache.org/proper/commons-io/，下面用例子分别介绍：
  1）  工具类
  2
    

    • 

  • 如何学习编程
lampcy
java编程C++c

    首先,我想说一下学习思想.学编程其实跟网络游戏有着类似的效果.开始的时候,你会对那些代码,函数等产生很大的兴趣,尤其是刚接触编程的人,刚学习第一种语言的人.可是,当你一步步深入的时候,你会发现你没有了以前那种斗志.就好象你在玩韩国泡菜网游似的,玩到一定程度,每天就是练级练级,完全是一个想冲到高级别的意志力在支持着你.而学编程就更难了,学了两个月后,总是觉得你好象全都学会了,却又什么都做不了,又没有
    

    • 

  • 架构师之spring-----spring3.0新特性的bean加载控制@DependsOn和@Lazy
nannan408
Spring3

    1.前言。
   如题。
2.描述。
  
@DependsOn用于强制初始化其他Bean。可以修饰Bean类或方法，使用该Annotation时可以指定一个字符串数组作为参数，每个数组元素对应于一个强制初始化的Bean。
@DependsOn({"steelAxe","abc"})
@Comp
    

    • 

  • Spring4+quartz2的配置和代码方式调度
Everyday都不同
代码配置spring4quartz2.x定时任务

    前言：这些天简直被quartz虐哭。。因为quartz 2.x版本相比quartz1.x版本的API改动太多，所以，只好自己去查阅底层API……
 
quartz定时任务必须搞清楚几个概念：
JobDetail——处理类
Trigger——触发器，指定触发时间，必须要有JobDetail属性，即触发对象
Scheduler——调度器，组织处理类和触发器，配置方式一般只需指定触发
    

    • 

  • Hibernate入门
tntxia
Hibernate

     
前言
 
使用面向对象的语言和关系型的数据库，开发起来很繁琐，费时。由于现在流行的数据库都不面向对象。Hibernate 是一个Java的ORM（Object/Relational Mapping）解决方案。
 
Hibernte不仅关心把Java对象对应到数据库的表中，而且提供了请求和检索的方法。简化了手工进行JDBC操作的流程。
 
如
    

    • 

  • Math类
xiaoxing598
Math

    一、Java中的数字（Math）类是final类，不可继承。
1、常数 PI：double圆周率 E：double自然对数
2、截取（注意方法的返回类型） double ceil(double d) 返回不小于d的最小整数 double floor(double d) 返回不大于d的整最大数 int round(float f) 返回四舍五入后的整数 long round
    

    •