shallowinggg
shallowinggg

Netty源码解析 —— concurrency

线程模型

概述

因为具有多核心或多个CPU 的计算机现在已经司空见惯，大多数的现代应用程序都利用了
复杂的多线程处理技术以有效地利用系统资源。相比之下，在早期的Java 语言中，我们使用多
线程处理的主要方式无非是按需创建和启动新的Thread来执行并发的任务单元——一种在高
负载下工作得很差的原始方式。Java 5 随后引入了Executor API，其线程池通过缓存和重用
Thread 极大地提高了性能。

基本的线程池化模式可以描述为：

  • 从池的空闲线程列表中选择一个Thread，并且指派它去运行一个已提交的任务（一个
    Runnable 的实现）；
  • 当任务完成时，将该Thread 返回给该列表，使其可被重用。

虽然池化和重用线程相对于简单地为每个任务都创建和销毁线程是一种进步，但是它并不能
消除由上下文切换所带来的开销，其将随着线程数量的增加很快变得明显，并且在高负载下愈演
愈烈。此外，仅仅由于应用程序的整体复杂性或者并发需求，在项目的生命周期内也可能会出现
其他和线程相关的问题。

Executor的执行逻辑

EventLoop

Netty 的EventLoop 是协同设计的一部分，它采用了两个基本的API：并发和网络编程。
首先，io.netty.util.concurrent 包构建在JDK 的java.util.concurrent 包上，用
来提供线程执行器。其次，io.netty.channel 包中的类，为了与Channel 的事件进行交互，
扩展了这些接口/类。

EventLoop类继承结构

在这个模型中，一个EventLoop 将由一个永远都不会改变的Thread 驱动，同时任务
（Runnable 或者Callable）可以直接提交给EventLoop 实现，以立即执行或者调度执行。
根据配置和可用核心的不同，可能会创建多个EventLoop 实例用以优化资源的使用，并且单个
EventLoop 可能会被指派用于服务多个Channel。

实现细节

Netty线程模型的卓越性能取决于对于当前执行的Thread的身份的确定，也就是说，确定它是否是分配给当前Channel以及它的EventLoop的那一个线程(EventLoop将负责处理一个Channel的整个生命周期内的所有事件)。

如果（当前）调用线程正是支撑EventLoop 的线程，那么所提交的代码块将会被（直接）
执行。否则，EventLoop 将调度该任务以便稍后执行，并将它放入到内部队列中。当EventLoop
下次处理它的事件时，它会执行队列中的那些任务/事件。这也就解释了Thread 是如何
与Channel 直接交互而无需在ChannelHandler 中进行额外同步的。

注意，每个EventLoop 都有它自已的任务队列，独立于任何其他的EventLoop。下图
展示了EventLoop 用于调度任务的执行逻辑。这是Netty 线程模型的关键组成部分。

EventLoop的执行逻辑

服务于Channel 的I/O 和事件的EventLoop 包含在EventLoopGroup 中。根据不同的
传输实现，EventLoop 的创建和分配方式也不同。

1. 异步传输

异步传输实现只使用了少量的EventLoop（以及和它们相关联的Thread），而且在当前的
线程模型中，它们可能会被多个Channel 所共享。这使得可以通过尽可能少量的Thread 来支
撑大量的Channel，而不是每个Channel 分配一个Thread。
图7-4 显示了一个EventLoopGroup，它具有3 个固定大小的EventLoop（每个EventLoop
都由一个Thread 支撑）。在创建EventLoopGroup 时就直接分配了EventLoop（以及支撑它们
的Thread），以确保在需要时它们是可用的。

用于非阻塞传输（如NIO 和AIO）的EventLoop 分配方式

EventLoopGroup 负责为每个新创建的Channel 分配一个EventLoop。在当前实现中，
使用顺序循环（round-robin）的方式进行分配以获取一个均衡的分布，并且相同的EventLoop
可能会被分配给多个Channel。（这一点在将来的版本中可能会改变。）

一旦一个Channel 被分配给一个EventLoop，它将在它的整个生命周期中都使用这个
EventLoop（以及相关联的Thread）。请牢记这一点，因为它可以使你从担忧你的Channel-
Handler 实现中的线程安全和同步问题中解脱出来。

另外，需要注意的是，EventLoop 的分配方式对ThreadLocal 的使用的影响。因为一个
EventLoop 通常会被用于支撑多个Channel，所以对于所有相关联的Channel 来说，
ThreadLocal 都将是一样的。这使得它对于实现状态追踪等功能来说是个糟糕的选择。然而，
在一些无状态的上下文中，它仍然可以被用于在多个Channel 之间共享一些重度的或者代价昂
贵的对象，甚至是事件。

2. 阻塞传输

用于像OIO（旧的阻塞I/O）这样的其他传输的设计略有不同，如图7-5 所示。这里每一个Channel 都将被分配给一个EventLoop（以及它的Thread）。如果你开发的应用程序使用过java.io 包中的阻塞I/O 实现，你可能就遇到过这种模型。

阻塞传输（如OIO）的EventLoop 分配方式

但是，正如同之前一样，得到的保证是每个Channel 的I/O 事件都将只会被一个Thread
（用于支撑该Channel 的EventLoop 的那个Thread）处理。这也是另一个Netty 设计一致性
的例子，它（这种设计上的一致性）对Netty 的可靠性和易用性做出了巨大贡献。

实现

介绍完Netty的线程模型后，让我看一下它是如何实现的。之前我们已经看到了EventLoop的类层级结构图，现在我们不管EventLoop，而是先看EventExecutorGroup以及对应的实现。

EventExecutorGroup

首先我们先明确一件事，EventExecutorGroup与常见的线程池类似，而EventExecutor虽然也继承了ExecutorService，但是它是一个特化的只维护一个线程的线程池，因此可以将其视为拥有线程池职能的线程。而一个EventExecutorGroup管理多个EventExecutor，此结构与我们熟悉的线程池模型更加相似。理解了这件事之后，关于EventExecutorGroup的实现将清晰许多。

EventExecutorGroup

AbstractEventExecutorGroup是EventExecutorGroup接口的基本实现，遵循前面的介绍的轮询(round-robin)模式，将每一个任务轮流分配给它所管理的EventExecutor。

@Override
public Future submit(Runnable task) {
    return next().submit(task);
}

/**
 * Returns one of the {@link EventExecutor}s managed by this {@link EventExecutorGroup}.
 */
EventExecutor next();

MultithreadEventExecutorGroup则实现了线程池的骨架，正如其名，它是一个支持多线程执行的EventExecutorGroup，与java.util.concurrent中实现的线程池类似。这个类的核心是它的构造方法，展现了它与EventExecutor之间是如何关联的：

private final EventExecutor[] children;


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) {
                for (int j = 0; j < i; j ++) {
                    children[j].shutdownGracefully();
                }

                for (int j = 0; j < i; j ++) {
                    EventExecutor e = children[j];
                    try {
                        while (!e.isTerminated()) {
                            e.awaitTermination(Integer.MAX_VALUE, TimeUnit.SECONDS);
                        }
                    } catch (InterruptedException interrupted) {
                        // Let the caller handle the interruption.
                        Thread.currentThread().interrupt();
                        break;
                    }
                }
            }
        }
    }

    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);
}


其中Executor只用来构造Thread，默认为一个EventExecutor对应一个Thread。注意execute方法：


public final class ThreadPerTaskExecutor implements Executor {
    private final ThreadFactory threadFactory;

    public ThreadPerTaskExecutor(ThreadFactory threadFactory) {
        if (threadFactory == null) {
            throw new NullPointerException("threadFactory");
        }
        this.threadFactory = threadFactory;
    }

    @Override
    public void execute(Runnable command) {
        threadFactory.newThread(command).start();
    }
}



而chooser字段代表了EventExcutor的选择策略(默认为轮询)：


public EventExecutorChooser newChooser(EventExecutor[] executors) {
    if (isPowerOfTwo(executors.length)) {
        return new PowerOfTwoEventExecutorChooser(executors);
    } else {
        return new GenericEventExecutorChooser(executors);
    }
}

private static final class PowerOfTwoEventExecutorChooser implements EventExecutorChooser {
    private final AtomicInteger idx = new AtomicInteger();
    private final EventExecutor[] executors;

    PowerOfTwoEventExecutorChooser(EventExecutor[] executors) {
        this.executors = executors;
    }

    @Override
    public EventExecutor next() {
        return executors[idx.getAndIncrement() & executors.length - 1];
    }
}

private static final class GenericEventExecutorChooser implements EventExecutorChooser {
    private final AtomicInteger idx = new AtomicInteger();
    private final EventExecutor[] executors;

    GenericEventExecutorChooser(EventExecutor[] executors) {
        this.executors = executors;
    }

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



这里有一点优化，即 & 操作相比 % 会快很多，所以当线程池的线程数量为pow2时，针对设计了next()方法。


choose字段在EventExecutorGroup#next()方法中使用，用以选择执行任务的线程。


@Override
public EventExecutor next() {
    return chooser.next();
}



构造EventExecutor的newChild()方法交由子类实现，以针对不同的场景进行定制。默认实现如下所示：


@Override
protected EventExecutor newChild(Executor executor, Object... args) throws Exception {
    return new DefaultEventExecutor(this, executor, (Integer) args[0], (RejectedExecutionHandler) args[1]);
}

public DefaultEventExecutor(EventExecutorGroup parent, Executor executor, int maxPendingTasks,
                            RejectedExecutionHandler rejectedExecutionHandler) {
    super(parent, executor, true, maxPendingTasks, rejectedExecutionHandler);
}

protected SingleThreadEventExecutor(EventExecutorGroup parent, Executor executor,
                                    boolean addTaskWakesUp, int maxPendingTasks,
                                    RejectedExecutionHandler rejectedHandler) {
    super(parent);
    this.addTaskWakesUp = addTaskWakesUp;
    this.maxPendingTasks = Math.max(16, maxPendingTasks);
    this.executor = ThreadExecutorMap.apply(executor, this);
    taskQueue = newTaskQueue(this.maxPendingTasks);
    rejectedExecutionHandler = ObjectUtil.checkNotNull(rejectedHandler, "rejectedHandler");
}



注意taskQueue = newTaskQueue(this.maxPendingTasks);方法，每个EventExecutor都自己维护一个任务队列，而不是EventExecutorGroup维护一个任务队列，因此一批任务都会由固定的EventExecutor进行执行，这样可以避免在编写代码时考虑并发控制，这个优势在ChannelHandler中体现。


关于EventExecutorGroup实现的说明到此为止，接下来讲述EventExecutor的实现类。













EventExecutor





在上面的继承体系中，顶层类AbstractEventExecutor继承了jdk提供的骨架类AbstractExecutorService，在此基础上提供了自己的一些功能，比如：


@Override
public EventExecutorGroup parent() {
    return parent;
}

@Override
public EventExecutor next() {
    return this;
}

@Override
public boolean inEventLoop() {
    return inEventLoop(Thread.currentThread());
}




其中next()方法我们在EventExecutorGroup的实现中提及过，EventExcutor继承了EventExecutorGroup接口，它的实现就是返回它自己。


而inEventLoop()则是核心方法，在之前的线程模型中，我们说过Netty的性能取决于对当前线程身份的确定，此方法就用于实现这一功能，关于此方法是如何带来性能提升，我们在后面再讨论。


AbstractScheduledEventExecutor类则增加了任务调度的功能，实现了ScheduledExecutorService接口。其内部维护了一个优先队列，以任务下一次执行时间为基准进行比较。


SingleThreadEventExecutor则实现了EventExecutor的核心功能，它的名字与MultithreadEventExecutorGroup相对应。


这个类的实现比较繁杂，有许多的辅助方法，我们从核心方法execute()进行切入，我们知道EventExecutor由EventExecutorGroup所控制，所以它的启动需要EventExecutorGroup帮助：


# EventExecutorGroup.java

@Override
public void execute(Runnable command) {
    next().execute(command);
}


# SingleThreadEventExecutor.java    -------------------------------------

@Override
public boolean inEventLoop() {
    return inEventLoop(Thread.currentThread());
}

@Override
public boolean inEventLoop(Thread thread) {
    return thread == this.thread;
}

@Override
public void execute(Runnable task) {
    if (task == null) {
        throw new NullPointerException("task");
    }

    boolean inEventLoop = inEventLoop();
    // 将任务直接增加到任务队列中，而不直接执行
    addTask(task);
    if (!inEventLoop) {
        // 首次启动时，thread字段还未初始化，所以inEventLoop()方法一定会返回false
        startThread();
        // 如果EventExecutor已经被关闭，取消此任务的执行（边界条件）
        if (isShutdown()) {
            boolean reject = false;
            try {
                if (removeTask(task)) {
                    reject = true;
                }
            } catch (UnsupportedOperationException e) {
                // The task queue does not support removal so the best thing we can do is to just move on and
                // hope we will be able to pick-up the task before its completely terminated.
                // In worst case we will log on termination.
            }
            if (reject) {
                reject();
            }
        }
    }

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


private void startThread() {
    if (state == ST_NOT_STARTED) {
        // CAS修改EventExecutor的状态为已启动
        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);
                }
            }
        }
    }
}



在介绍真正的启动过程之前，我们先回忆一下EventExecutor的构造方法：


protected SingleThreadEventExecutor(EventExecutorGroup parent, Executor executor,
                                    boolean addTaskWakesUp, int maxPendingTasks,
                                    RejectedExecutionHandler rejectedHandler) {
    super(parent);
    this.addTaskWakesUp = addTaskWakesUp;
    this.maxPendingTasks = Math.max(16, maxPendingTasks);
    this.executor = ThreadExecutorMap.apply(executor, this);
    taskQueue = newTaskQueue(this.maxPendingTasks);
    rejectedExecutionHandler = ObjectUtil.checkNotNull(rejectedHandler, "rejectedHandler");
}

public static Executor apply(final Executor executor, final EventExecutor eventExecutor) {
    ObjectUtil.checkNotNull(executor, "executor");
    ObjectUtil.checkNotNull(eventExecutor, "eventExecutor");
    return new Executor() {
        @Override
        public void execute(final Runnable command) {
            executor.execute(apply(command, eventExecutor));
        }
    };
}

public static Runnable apply(final Runnable command, final EventExecutor eventExecutor) {
    ObjectUtil.checkNotNull(command, "command");
    ObjectUtil.checkNotNull(eventExecutor, "eventExecutor");
    return new Runnable() {
        @Override
        public void run() {
            setCurrentEventExecutor(eventExecutor);
            try {
                command.run();
            } finally {
                setCurrentEventExecutor(null);
            }
        }
    };
}

private static void setCurrentEventExecutor(EventExecutor executor) {
    mappings.set(executor);
}

private static final FastThreadLocal mappings = new FastThreadLocal();



这一步对Runnable进行装饰，以此将之前EventExecutorGroup传入的Executor所产生的Thread与EventExecutor绑定起来。


doStartThread()方法调用了Executor的executor的方法，构造一个新的线程，并执行上面修饰后的Runnable。


private void doStartThread() {
    assert thread == null;
    executor.execute(new Runnable() {
        @Override
        public void run() {
            thread = Thread.currentThread();
            if (interrupted) {
                thread.interrupt();
            }

            boolean success = false;
            updateLastExecutionTime();
            try {
                SingleThreadEventExecutor.this.run();
                success = true;
            } catch (Throwable t) {
                logger.warn("Unexpected exception from an event executor: ", t);
            } finally {
                for (;;) {
                    int oldState = state;
                    if (oldState >= ST_SHUTTING_DOWN || STATE_UPDATER.compareAndSet(
                            SingleThreadEventExecutor.this, oldState, ST_SHUTTING_DOWN)) {
                        break;
                    }
                }

                // Check if confirmShutdown() was called at the end of the loop.
                if (success && gracefulShutdownStartTime == 0) {
                    if (logger.isErrorEnabled()) {
                        logger.error("Buggy " + EventExecutor.class.getSimpleName() + " implementation; " +
                                SingleThreadEventExecutor.class.getSimpleName() + ".confirmShutdown() must " +
                                "be called before run() implementation terminates.");
                    }
                }

                try {
                    // Run all remaining tasks and shutdown hooks.
                    for (;;) {
                        if (confirmShutdown()) {
                            break;
                        }
                    }
                } finally {
                    try {
                        cleanup();
                    } finally {
                        // Lets remove all FastThreadLocals for the Thread as we are about to terminate and notify
                        // the future. The user may block on the future and once it unblocks the JVM may terminate
                        // and start unloading classes.
                        // See https://github.com/netty/netty/issues/6596.
                        FastThreadLocal.removeAll();

                        STATE_UPDATER.set(SingleThreadEventExecutor.this, ST_TERMINATED);
                        threadLock.countDown();
                        if (logger.isWarnEnabled() && !taskQueue.isEmpty()) {
                            logger.warn("An event executor terminated with " +
                                    "non-empty task queue (" + taskQueue.size() + ')');
                        }
                        terminationFuture.setSuccess(null);
                    }
                }
            }
        }
    });
}

上面的代码虽然很长，但是核心内容只有：

```java
try {
    SingleThreadEventExecutor.this.run();
    success = true;
}



SingleThreadEventExecutor并没有实现run()方法，而是让其在子类中实现，让我们看一下默认实现：


@Override
protected void run() {
    for (;;) {
        Runnable task = takeTask();
        if (task != null) {
            task.run();
            updateLastExecutionTime();
        }

        if (confirmShutdown()) {
            break;
        }
    }
}



run()方法内部是一个死循环，不断从任务队列中获取任务然后执行，直到EventExecutor被关闭。


protected Runnable takeTask() {
    assert inEventLoop();
    if (!(taskQueue instanceof BlockingQueue)) {
        throw new UnsupportedOperationException();
    }

    BlockingQueue taskQueue = (BlockingQueue) this.taskQueue;
    for (;;) {
        ScheduledFutureTask scheduledTask = peekScheduledTask();
        if (scheduledTask == null) {
            Runnable task = null;
            try {
                task = taskQueue.take();
                if (task == WAKEUP_TASK) {
                    task = null;
                }
            } catch (InterruptedException e) {
                // Ignore
            }
            return task;
        } else {
            long delayNanos = scheduledTask.delayNanos();
            Runnable task = null;
            // 如果定时队列中有任务，并且还未到执行时间，
            // 那么尝试从taskQueue中获取任务并执行，直到定时任务
            // 可以执行
            if (delayNanos > 0) {
                try {
                    task = taskQueue.poll(delayNanos, TimeUnit.NANOSECONDS);
                } catch (InterruptedException e) {
                    // Waken up.
                    return null;
                }
            }
            if (task == null) {
                // We need to fetch the scheduled tasks now as otherwise there may be a chance that
                // scheduled tasks are never executed if there is always one task in the taskQueue.
                // This is for example true for the read task of OIO Transport
                // See https://github.com/netty/netty/issues/1614
                fetchFromScheduledTaskQueue();
                task = taskQueue.poll();
            }

            if (task != null) {
                return task;
            }
        }
    }
}

private boolean fetchFromScheduledTaskQueue() {
    long nanoTime = AbstractScheduledEventExecutor.nanoTime();
    Runnable scheduledTask  = pollScheduledTask(nanoTime);
    while (scheduledTask != null) {
        if (!taskQueue.offer(scheduledTask)) {
            // No space left in the task queue add it back to the scheduledTaskQueue so we pick it up again.
            scheduledTaskQueue().add((ScheduledFutureTask) scheduledTask);
            return false;
        }
        scheduledTask  = pollScheduledTask(nanoTime);
    }
    return true;
}



此处的实现与java.util.concurrent中线程池的工作线程基本相似，不过最重要的是线程模型之间的区别。


takeTask()方法在之前的版本如下：


Runnable task;
if (delayNanos > 0) {
    try {
        task = taskQueue.poll(delayNanos, TimeUnit.NANOSECONDS);
    } catch (InterruptedException e) {
        return null;
    }
} else {
    task = taskQueue.poll();
}
if (task == null) {
    fetchFromDelayedQueue();
    task = taskQueue.poll();
}



这个版本的实现有一个bug，如果taskQueue中一直有任务，那么定时任务将无法被执行。


最后，让我看看一下EventExecutor是如何被关闭的，虽然ExecutorService提供了shutdown()方法，但是它的接口语义是线程池关闭后将不能再接受任务，这会使得某些任务无法被完成，导致出现一些问题，所以Netty定义了一个新的接口叫做shutdownGracefully，用来取代shutdown()。


@Override
public Future shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit) {
    if (quietPeriod < 0) {
        throw new IllegalArgumentException("quietPeriod: " + quietPeriod + " (expected >= 0)");
    }
    if (timeout < quietPeriod) {
        throw new IllegalArgumentException(
                "timeout: " + timeout + " (expected >= quietPeriod (" + quietPeriod + "))");
    }
    if (unit == null) {
        throw new NullPointerException("unit");
    }

    if (isShuttingDown()) {
        return terminationFuture();
    }

    boolean inEventLoop = inEventLoop();
    boolean wakeup;
    int oldState;
    for (;;) {
        if (isShuttingDown()) {
            return terminationFuture();
        }
        int newState;
        wakeup = true;
        oldState = state;
        if (inEventLoop) {
            newState = ST_SHUTTING_DOWN;
        } else {
            switch (oldState) {
                case ST_NOT_STARTED:
                case ST_STARTED:
                    newState = ST_SHUTTING_DOWN;
                    break;
                default:
                    newState = oldState;
                    wakeup = false;
            }
        }
        if (STATE_UPDATER.compareAndSet(this, oldState, newState)) {
            break;
        }
    }
    gracefulShutdownQuietPeriod = unit.toNanos(quietPeriod);
    gracefulShutdownTimeout = unit.toNanos(timeout);

    if (ensureThreadStarted(oldState)) {
        return terminationFuture;
    }

    if (wakeup) {
        wakeup(inEventLoop);
    }

    return terminationFuture();
}




这个接口拥有三个参数long quietPeriod, long timeout, TimeUnit unit。如果指定了quietPeriod不为0，那么EventExecutor在执行完当前任务列表中的任务后，并不会立刻关闭，而是会继续等待新任务，timeout的作用与此类似。调用此接口后，线程池的状态变更为ST_SHUTTING_DOWN，进入一段静默等待的时期，如果有新任务到来，它可以成功被接受。


工作线程需要配置shutdownGracefully工作，让我们再看一下run()方法：


protected void run() {
    for (;;) {
        Runnable task = takeTask();
        if (task != null) {
            task.run();
            updateLastExecutionTime();
        }

        if (confirmShutdown()) {
            break;
        }
    }
}


protected boolean confirmShutdown() {
    if (!isShuttingDown()) {
        return false;
    }

    if (!inEventLoop()) {
        throw new IllegalStateException("must be invoked from an event loop");
    }

    cancelScheduledTasks();

    if (gracefulShutdownStartTime == 0) {
        gracefulShutdownStartTime = ScheduledFutureTask.nanoTime();
    }

    if (runAllTasks() || runShutdownHooks()) {
        if (isShutdown()) {
            // Executor shut down - no new tasks anymore.
            return true;
        }

        // There were tasks in the queue. Wait a little bit more until no tasks are queued for the quiet period or
        // terminate if the quiet period is 0.
        // See https://github.com/netty/netty/issues/4241
        if (gracefulShutdownQuietPeriod == 0) {
            return true;
        }
        wakeup(true);
        return false;
    }

    final long nanoTime = ScheduledFutureTask.nanoTime();

    if (isShutdown() || nanoTime - gracefulShutdownStartTime > gracefulShutdownTimeout) {
        return true;
    }

    if (nanoTime - lastExecutionTime <= gracefulShutdownQuietPeriod) {
        // Check if any tasks were added to the queue every 100ms.
        // TODO: Change the behavior of takeTask() so that it returns on timeout.
        wakeup(true);
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            // Ignore
        }

        return false;
    }

    // No tasks were added for last quiet period - hopefully safe to shut down.
    // (Hopefully because we really cannot make a guarantee that there will be no execute() calls by a user.)
    return true;
}




任务线程每执行一次任务后，都会去检查线程池是否被关闭，如果线程池处于ST_SHUTTING_DOWN状态，工作线程将进入静默期，等待线程池彻底关闭或者超时。如果quietPeriod指定为0，那么工作线程执行完任务队列中的所有任务后，工作线程将停止，线程池彻底关闭。否则，它会等待超时或者quietPeriod到达，在此期间每100ms检查一次任务队列，如果有新任务到来那么执行它。


EventLoopGroup


EventLoopGruop的类层次结构如下所示，虽然DefaultEventLoopGroup只是一个简单的实现类，但是NioEventLoopGroup等常用组件都和它的继承体系差不多，在此只看其基本实现，排除掉和IO关联的实现类。













EventLoopGroup





从上图可见，MultithreadEventLoopGroup直接继承自MultithreadEventExecutorGroup，在原本并发架构的基础上，进行定制，实现了EventLoopGroup接口的一些方法。在这种设计下，并发框架保持了良好的可扩展性。


MultithreadEventExecutorGroup与DefaultEventLoopGroup的实现非常简单，只定义了一些构造方法，不再多说。


EventLoop


DefaultEventLoop与DefaultEventLoopGroup一样，实现了EventLoop接口，将线程与NIO连接到了一起。













DefaultEventLoop



























你可能感兴趣的:(Netty源码解析 —— concurrency)






    

  • ArrayList 源码解析
程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea

    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    

    • 

  • Istio pilot-discovery服务发现源码解析（1.13版本）
xidianjiapei001
#Istioistio云原生服务发现

    Istiopilot-discovery服务发现介绍工作机制初始化初始化Config控制器初始化Service控制器controller初始化NamespaceServiceNodePodPilotDiscovery各组件启动流程DiscoveryServer接收Envoy的gRPC连接请求流程Config变化后向Envoy推送更新的流程总结参考介绍IstioPilot的代码分为Pilot-Dis
    

    • 

  • 数据库系统 第53节 数据库并发控制
hummhumm
数据库oraclepythonjavadatabasesql后端

    数据库并发控制是确保在多个用户或进程同时访问数据库时，数据的完整性和一致性得到维护的一种机制。并发控制技术主要分为两大类：乐观并发控制和悲观并发控制。下面将详细叙述这两种技术，以及多版本并发控制（MVCC），这是一种在数据库系统中广泛使用的并发控制方法。乐观并发控制(OptimisticConcurrencyControl,OCC)乐观并发控制的核心思想是假设事务之间的冲突发生的概率较低，因此它允
    

    • 

  • Java集合类框架源码分析 之 RoleList源码解析 【6】
yunzhonghefei
Java集合类源码分析RoleList源码解析

    该类继承于ArrayList，针对Role进行了一些扩展。其他方法和ArrayList中基本相同，源码不做针对性分析：看一下类简介：/***代表了一个roles的列表，作为方法setRoles()的参数，去创建一个关联关系，并且尝试在同一个关系中设置多个角色。*ARoleListrepresentsalistofroles(Roleobjects).Itisusedas*parameterwhen
    

    • 

  • VITS 源码解析2-模型概述
迪三
#NN_Audio音频人工智能

    VITs是文本到语音(Text-to-Speech,TTS)任务中最流行的技术之一，其实现思路是将文本语音信息融合到了HiFiGAN潜空间内,通过文本控制HiFiGAN的生成器，输出含文本语义的声音。VITs主要以GAN的方式训练,其生成器G是SynthesizerTrn，判别器D是MPD。VITS的判别器几乎和HiFiGAN一样，生成器则融合了文本、时序、声音三大类模型1.文件概述模型部分包含三
    

    • 

  • netty-简易聊天
2401_84046645
程序员java开发语言

    publicvoidsend(Stringtext){channel.writeAndFlush(Unpooled.copiedBuffer(text.getBytes()));}publicvoidcloseConnect(){send(“bye”);channel.close();}}classMyHandlerextendsChannelInboundHandlerAdapter{@Over
    

    • 

  • Netty权威指南：Netty总结-高性能与可靠性
Ty_1106
Nettyjava网络rpc

    第二十二章高性能之道22.1RPC调用性能模型分析22.1.1传统RPC调用性能差三宗罪：网络传输采用同步阻塞I/O导致经常性阻塞序列化性能差线程模型问题22.1.2I/O通信性能三要素传输：BIO、NIO或者AIO协议：HTTP公有协议，内部私有协议线程：数据报如何读取，Reactor线程模型22.2Netty高性能之道22.2.1异步非阻塞通信I/O多路复用技术22.2.2高效的Reactor
    

    • 

  • netty4源码阅读与分析---netty线程模型
红尘之一骑
javaNIOnetty源码阅读与分析

    本文主要说下我自己对netty线程模型的理解，以及这样的线程模型的好处。通俗的来讲，netty的线程模型描述的就是老板和员工的故事。老板(通常情况下是一个老板)负责接活，与客户沟通，协调(netty的accept),谈成后(通道建立)，他需要从员工中选出一位员工来负责处理后续具体的事宜(worker线程，这里我们有16位员工，编号1-16)，员工做事时按照任务的先后顺序进行处理，这样可以避免错乱，
    

    • 

  • C++新特性以及应用场景
平凡而伟大(心之所向)
编程语言c++开发语言

    C++的新特性可以大致分为以下几类：模板（Templates）：提高代码复用性，包括模板函数和模板类。异常处理（ExceptionHandling）：提供了一套结构化的错误处理机制。异步编程（ConcurrencyandMultithreading）：提供了线程和原子操作等工具。智能指针（SmartPointers）：自动管理内存，如std::unique_ptr和std::shared_ptr。
    

    • 

  • RBtree
努力的小带土
侯捷老师STLc++蓝桥杯

    终结B站没人能讲清楚红黑树的历史，不服等你来踢馆！-【码炫课堂收费课节选之-红黑树源码解析及手写红黑树】_哔哩哔哩_bilibiliB站的听课记录，并写下如下红黑树c++版本代码，该课程真的史诗级推荐！/*RBtreeNode.h*****/#pragmaonceenum{RED=false,BLACK=true};templateclassRBtreeNode{public://红黑树的左右节点
    

    • 

  • 深入理解Kubernetes：kube-scheduler源码解析
mujingluo
kubernetes容器云原生

    Kubernetes的调度器（kube-scheduler）是整个系统中至关重要的组件，它负责将待调度的Pods分配到合适的节点上。本文将深入分析kube-scheduler的源码，揭示其内部工作机制。kube-scheduler的核心功能kube-scheduler的核心功能包括：监听Pod变化：通过KubernetesAPI监听所有未调度的Pods。过滤（Filtering）：根据一系列规则（
    

    • 

  • 【Vesta发号器源码】PropertyMachineIdsProvider
DeanChangDM

    Vesta发号器源码解析——PropertyMachineIdsProvider属性配置文件持有Id的模式,没啥东西，比单个的多了一个获取下一个的方法封装实现上略有一点点区别privatelong[]machineIds;privateintcurrentIndex;publiclonggetNextMachineId(){returngetMachineId();}publiclonggetMa
    

    • 

  • StarRocks分布式元数据源码解析
不甚了然
Iceberg知识集StarRocksIceberg数据湖湖仓一体大数据

    1.支持元数据表https://github.com/StarRocks/starrocks/pull/44276/files核心类：LogicalIcebergMetadataTable，Iceberg元数据表，将元数据的各个字段做成表的列，后期可以通过sql操作从元数据获取字段，这个表的组成字段是DataFile相关的字段public static LogicalIcebergMetadata
    

    • 

  • 【Starrocks】建表篇Fe源码解析
数算七弦
Starrocks大数据

    Starrocks系统架构简述现在市面上主流的OLAP存算一体架构主要有两类进程：Frontend（FE）和Backend（BE）Frontend一般是用Java写的。主要职责有：接收用户连接请求（MySQL协议层）元数据存储与管理查询语句的解析与查询计划的生成集群管控Backend一般是用C++写的，主要职责有：数据存储与管理查询计划的执行建表语句的执行过程与Mysql协议层交互词法解析语法解析
    

    • 

  • 智能农业设备软件工程师如何集成和管理农业物联网（IoT）平台
openwin_top
智能农业设备软件工程师物联网python开发语言深度学习大数据智能农业

    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位集成和管理农业物联网（IoT）平台涉及多个步骤，包括设备连接、数据收集、数据传输、数据存储、数据分析和展示。以下是详细分析和示例代码展示。1.设备连接和数据收集首先，智能农业设备需要能够与传感器和执
    

    • 

  • 智能农业设备软件工程师如何集成和管理农业设备的远程更新系统
openwin_top
智能农业设备软件工程师深度学习大数据物联网人工智能网络智能农业

    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位集成和管理农业设备的远程更新系统涉及多个技术层面，包括设备固件的安全更新、版本控制、网络通信，以及设备管理平台的开发。下面我们详细分析这些步骤，并提供一个基本的示例代码来展示如何实现这个系统。1.系
    

    • 

  • 智能农业设备软件工程师如何处理设备的远程诊断和修复
openwin_top
智能农业设备软件工程师网络智能农业物联网人工智能大数据深度学习

    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位处理智能农业设备的远程诊断和修复涉及几个关键步骤，包括设备的数据采集、数据传输、远程诊断、远程控制和修复。以下是详细分析和示例代码：1.数据采集智能农业设备通常配备传感器和控制器，这些设备不断采集环
    

    • 

  • android10 按键音量调节源码解析
@OuYang
android

    /frameworks/base/services/core/java/com/android/server/policy/PhoneWindowManager.javastaticIAudioServicegetAudioService(){IAudioServiceaudioService=IAudioService.Stub.asInterface(ServiceManager.checkS
    

    • 

  • android10 Settings源码解析
@OuYang
android

    /packages/apps/Settings/AndroidManifest.xml.................................................................................activity-alias是Android里为了重复使用Activity而设计的。对于activity-alias标签，它有一个属性叫android:
    

    • 

  • MyBatis 源码解析：XMLScriptBuilder 工作机制
捕风捉你
MyBatis源码解读mybatisjava

    摘要MyBatis提供了强大的动态SQL功能，它通过解析XML配置文件中的动态SQL标签（如、、等），来实现灵活的SQL生成。而XMLScriptBuilder类则负责解析这些XML配置并生成最终的SQL语句。本文将详细解析XMLScriptBuilder的工作机制，并通过自定义实现来帮助您深入理解该类的功能。前言MyBatis中的动态SQL功能是通过解析XML配置文件实现的。XML文件中包含了动
    

    • 

  • Lt-8 Multithreading
yanlingyun0210
java

    IntendedLearningOutcomesTounderstandtheconceptofconcurrency.Tounderstandthedifferenceofaprocessandathread.TodefineathreadusingtheThreadclassandRunnableinterface.TocontrolthreadswithvariousThreadmethod
    

    • 

  • 深度长文解析SpringWebFlux响应式框架15个核心组件源码
快乐非自愿
javaspring

    SpringWebFlux介绍SpringWebFlux是SpringFramework5.0版本引入的一个响应式Web框架，它与SpringMVC并存，提供了一种全新的编程范式，支持异步非阻塞的Web应用开发。WebFlux完全基于响应式编程模型，支持ReactiveStreams规范，可以在诸如Netty、Undertow以及Servlet3.1+容器上运行。WebFlux的核心控制器是Dis
    

    • 

  • Java网络编程：IO，NIO与Netty
坚持是一种态度
javajava网络编程NettyJavaIONIONIO与Netty

    Java网络编程：IO，NIO与NettyJava网络编程：IO，NIO与NettyJavaI/O相关概念同步与异步阻塞与非阻塞OIONIOAIOreactor模型proactor模型JavaIO应用场景Netty简介NIO与Netty生产使用Java网络编程：IO，NIO与Netty新公司新项目，项目需要在硬件和软件平台进行信息传递，具体来说使用Netty。硬件和软件使用socket连接，硬件作
    

    • 

  • java reactor模式例子_Netty Reactor模式实现原理详解
weixin_39923623
javareactor模式例子

    在前面的文章中(Reactor模型详解)，我们讲解了Reactor模式的各种演变形式，本文主要讲解的则是Netty是如何实现Reactor模式的。这里关于Netty实现的Reactor模式，需要说明的是，其实现的模式如下图所示：对于Netty使用的Reactor模式，其主要特点如下：使用一个线程作为mainReactor，专门用于监听客户端的连接事件，当获取到事件之后就将该事件交由Acceptor
    

    • 

  • 快速理解 并发量、吞吐量、日活、QPS、TPS、RPS、RT、PV、UV、DAU、GMV
小松聊PHP进阶
面试后端服务器数据库sqlmysqlnosql软件工程

    并发与并行并发：由于CPU数量或核心数量不够，多个任务并不一定是同时进行的，这些任务交替执行（分配不同的CPU时间片，进程或者线程的上下文切换），所以是伪并行。并行：多个任务可以在同一时刻同时执行，通常需要多个或多核处理器，不需要上下文切换，真正的并行。并发量（Concurrency）概念：并发或并行，是程序和运维本身要考虑的问题。而并发量，通常是不考虑程序并发或并行执行，只考虑一个服务端程序单位
    

    • 

  • 谈一谈MVCC
神州永泰
大数据mysqljavaoracle数据库jvm

    一MVCC的定义MVCC（Multi-VersionConcurrencyControl，多版本并发控制）是一种用于数据库管理系统（DBMS）中的并发控制方法，它允许数据库读写操作不加锁地并发执行，从而提高了数据库系统的并发性能。MVCC主要是通过维护数据的多个版本来实现这一点的，每个事务在执行时都会基于数据的某个版本进行操作，这样即使多个事务同时操作同一数据，也不会相互干扰。二MVCC的主要特点
    

    • 

  • Netty实战二-实现UDP的单播和广播(1)
2401_84048671
程序员udp网络协议网络

    publicclassAnswerHandlerextendsSimpleChannelInboundHandler{/应答的具体内容从常量字符串数组中取得，由nextQuote方法随机获取/privatestaticfinalString[]DICTIONARY={“一个男生暗恋一个女生很久了。一天自习课上，男生偷偷的传了小纸条给女生，上面写着“其实我注意你很久了”。不一会儿，女生传了另一张纸条
    

    • 

  • c#视觉应用开发中如何使用Emgu CV在C#中进行图像处理？
openwin_top
C#视觉应用开发问题系列c#图像处理开发语言

    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位EmguCV是OpenCV的.NET包装器，可以让开发者在.NET语言（如C#）中使用OpenCV的功能进行图像处理。在进行图像处理时，EmguCV提供了丰富的API可以使用。以下是使用EmguCV
    

    • 

  • ray.tune文档总结
AI大司马
python人工智能深度学习

    ray.tune文档总结tune.runconfig指定超参数的搜索方法ConcurrencyLimiter搜索算法scheduler试验调度程序分析资源（并行、GPU、分布式）原文档请看这里https://docs.ray.io/en/latest/tune/key-concepts.htmltune.run执行超参数调整、用于管理实验，例如日志检查、提前停止tune.run(trainable
    

    • 

  • netty源码解读三（NioEventLoop）
orcharddd_real
nettyjavanetty

    NioEventLoop初始化EventExecutor类型的数组数组大小默认为cpu数量的两倍，遍历数组，通过newNioEventLoop(xxx)往数组中添加元素，NioEventLoop继承了EventExecutor；每次需要线程时，执行chooser的next方法从数组中取出一个线程；关键代码打开netty源码，找到example包下的EchoService类，追溯创建boss线程组和
    

    • 

  • jsonp 常用util方法
hw1287789687
jsonpjsonp常用方法jsonp callback

    jsonp 常用java方法
(1)以jsonp的形式返回:函数名(json字符串)
/***
* 用于jsonp调用
* @param map : 用于构造json数据
* @param callback : 回调的javascript方法名
* @param filters : <code>SimpleBeanPropertyFilter theFilt
    

    • 

  • 多线程场景
alafqq
多线程

    0
能不能简单描述一下你在java web开发中需要用到多线程编程的场景？0
对多线程有些了解，但是不太清楚具体的应用场景，能简单说一下你遇到的多线程编程的场景吗？
Java多线程
2012年11月23日 15:41 Young9007 Young9007
4
0 0 4
Comment添加评论关注(2)
3个答案 按时间排序 按投票排序
0
0
最典型的如：
1、
    

    • 

  • Maven学习——修改Maven的本地仓库路径
Kai_Ge
maven

          安装Maven后我们会在用户目录下发现.m2 文件夹。默认情况下，该文件夹下放置了Maven本地仓库.m2/repository。所有的Maven构件(artifact)都被存储到该仓库中，以方便重用。但是windows用户的操作系统都安装在C盘，把Maven仓库放到C盘是很危险的，为此我们需要修改Maven的本地仓库路径。
 
 
    

    • 

  • placeholder的浏览器兼容
120153216
placeholder

    【前言】
自从html5引入placeholder后，问题就来了，
不支持html5的浏览器也先有这样的效果，
各种兼容，之前考虑，今天测试人员逮住不放，
想了个解决办法，看样子还行，记录一下。
 
【原理】
不使用placeholder，而是模拟placeholder的效果，
大概就是用focus和focusout效果。
 
【代码】
<scrip
    

    • 

  • debian_用iso文件创建本地apt源
2002wmj
Debian

    1.将N个debian-506-amd64-DVD-N.iso存放于本地或其他媒介内，本例是放在本机/iso/目录下
2.创建N个挂载点目录
如下：
debian:~#mkdir –r /media/dvd1
debian:~#mkdir –r /media/dvd2
debian:~#mkdir –r /media/dvd3
….
debian:~#mkdir –r /media
    

    • 

  • SQLSERVER耗时最长的SQL
357029540
SQL Server

    对于DBA来说，经常要知道存储过程的某些信息：
1.   执行了多少次
2.   执行的执行计划如何
3.   执行的平均读写如何
4.   执行平均需要多少时间
列名          &
    

    • 

  • com/genuitec/eclipse/j2eedt/core/J2EEProjectUtil
7454103
eclipse

    今天eclipse突然报了com/genuitec/eclipse/j2eedt/core/J2EEProjectUtil 错误，并且工程文件打不开了，在网上找了一下资料，然后按照方法操作了一遍，好了，解决方法如下：
错误提示信息：
An error has occurred.See error log for more details.
Reason:
com/genuitec/
    

    • 

  • 用正则删除文本中的html标签
adminjun
javahtml正则表达式去掉html标签

    使用文本编辑器录入文章存入数据中的文本是HTML标签格式，由于业务需要对HTML标签进行去除只保留纯净的文本内容，于是乎Java实现自动过滤。
如下：
public static String Html2Text(String inputString) {
String htmlStr = inputString; // 含html标签的字符串
String textSt
    

    • 

  • 嵌入式系统设计中常用总线和接口
aijuans
linux 基础

                   嵌入式系统设计中常用总线和接口
 
      任何一个微处理器都要与一定数量的部件和外围设备连接，但如果将各部件和每一种外围设备都分别用一组线路与CPU直接连接，那么连线
    

    • 

  • Java函数调用方式——按值传递
ayaoxinchao
java按值传递对象基础数据类型

    Java使用按值传递的函数调用方式，这往往使我感到迷惑。因为在基础数据类型和对象的传递上，我就会纠结于到底是按值传递，还是按引用传递。其实经过学习，Java在任何地方，都一直发挥着按值传递的本色。
 
首先，让我们看一看基础数据类型是如何按值传递的。
 
public static void main(String[] args) {
int a = 2; 
    

    • 

  • ios音量线性下降
bewithme
ios音量

    直接上代码吧
 
//second 几秒内下降为0
- (void)reduceVolume:(int)second {
KGVoicePlayer *player = [KGVoicePlayer defaultPlayer];
if (!_flag) {
_tempVolume = player.volume;

    

    • 

  • 与其怨它不如爱它
bijian1013
选择理想职业规划

            抱怨工作是年轻人的常态，但爱工作才是积极的心态，与其怨它不如爱它。
        一般来说，在公司干了一两年后，不少年轻人容易产生怨言，除了具体的埋怨公司“扭门”，埋怨上司无能以外，也有许多人是因为根本不爱自已的那份工作，工作完全成了谋生的手段，跟自已的性格、专业、爱好都相差甚远。
  
    

    • 

  • 一边时间不够用一边浪费时间
bingyingao
工作时间浪费

    一方面感觉时间严重不够用，另一方面又在不停的浪费时间。
每一个周末，晚上熬夜看电影到凌晨一点，早上起不来一直睡到10点钟，10点钟起床，吃饭后玩手机到下午一点。
精神还是很差，下午像一直野鬼在城市里晃荡。
为何不尝试晚上10点钟就睡，早上7点就起，时间完全是一样的，把看电影的时间换到早上，精神好，气色好，一天好状态。
控制让自己周末早睡早起，你就成功了一半。
有多少个工作
    

    • 

  • 【Scala八】Scala核心二：隐式转换
bit1129
scala

    Implicits work like this: if you call a method on a Scala object, and the Scala compiler does not see a definition for that method in the class definition for that object, the compiler will try to con
    

    • 

  • sudoku slover in Haskell (2)
bookjovi
haskellsudoku

    继续精简haskell版的sudoku程序，稍微改了一下，这次用了8行，同时性能也提高了很多，对每个空格的所有解不是通过尝试算出来的，而是直接得出。
 
board = [0,3,4,1,7,0,5,0,0,
0,6,0,0,0,8,3,0,1,
7,0,0,3,0,0,0,0,6,
5,0,0,6,4,0,8,0,7,

    

    • 

  • Java-Collections Framework学习与总结-HashSet和LinkedHashSet
BrokenDreams
linkedhashset

            本篇总结一下两个常用的集合类HashSet和LinkedHashSet。
        它们都实现了相同接口java.util.Set。Set表示一种元素无序且不可重复的集合；之前总结过的java.util.List表示一种元素可重复且有序
    

    • 

  • 读《研磨设计模式》-代码笔记-备忘录模式-Memento
bylijinnan
java设计模式

    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/
import java.util.ArrayList;
import java.util.List;
/*
* 备忘录模式的功能是，在不破坏封装性的前提下，捕获一个对象的内部状态，并在对象之外保存这个状态，为以后的状态恢复作“备忘” 
    

    • 

  • 《RAW格式照片处理专业技法》笔记
cherishLC
PS

    注意，这不是教程！仅记录楼主之前不太了解的
一、色彩（空间）管理
作者建议采用ProRGB（色域最广），但camera raw中设为ProRGB，而PS中则在ProRGB的基础上，将gamma值设为了1.8（更符合人眼）
注意：bridge、camera raw怎么设置显示、输出的颜色都是正确的（会读取文件内的颜色配置文件），但用PS输出jpg文件时，必须先用Edit->conv
    

    • 

  • 使用 Git 下载 Spring 源码 编译 for Eclipse
crabdave
eclipse

    使用 Git 下载 Spring 源码 编译 for Eclipse
 
1、安装gradle，下载 http://www.gradle.org/downloads
配置环境变量GRADLE_HOME，配置PATH  %GRADLE_HOME%/bin，cmd，gradle -v
 
2、spring4 用jdk8 下载 https://jdk8.java.
    

    • 

  • mysql连接拒绝问题
daizj
mysql登录权限

    mysql中在其它机器连接mysql服务器时报错问题汇总
一、[running][email protected]:~$mysql -uroot -h 192.168.9.108 -p   //带-p参数，在下一步进行密码输入
Enter password:    //无字符串输入
ERROR 1045 (28000): Access 
    

    • 

  • Google Chrome 为何打压 H.264
dsjt
applehtml5chromeGoogle

    Google 今天在 Chromium 官方博客宣布由于 H.264 编解码器并非开放标准，Chrome 将在几个月后正式停止对 H.264 视频解码的支持，全面采用开放的 WebM 和 Theora 格式。
Google 在博客上表示，自从 WebM 视频编解码器推出以后，在性能、厂商支持以及独立性方面已经取得了很大的进步，为了与 Chromium 现有支持的編解码器保持一致，Chrome
    

    • 

  • yii 获取控制器名 和方法名
dcj3sjt126com
yiiframework

    1. 获取控制器名
在控制器中获取控制器名:  $name = $this->getId();
在视图中获取控制器名:    $name = Yii::app()->controller->id; 
 
2. 获取动作名 
在控制器beforeAction()回调函数中获取动作名:  $name = 
    

    • 

  • Android知识总结（二）
come_for_dream
android

    明天要考试了，速速总结如下
 
1、Activity的启动模式
       standard：每次调用Activity的时候都创建一个（可以有多个相同的实例，也允许多个相同Activity叠加。）
       singleTop：可以有多个实例，但是不允许多个相同Activity叠加。即，如果Ac
    

    • 

  • 高洛峰收徒第二期：寻找未来的“技术大牛” ——折腾一年，奖励20万元
gcq511120594
工作项目管理

    高洛峰，兄弟连IT教育合伙人、猿代码创始人、PHP培训第一人、《细说PHP》作者、软件开发工程师、《IT峰播》主创人、PHP讲师的鼻祖！
首期现在的进程刚刚过半，徒弟们真的很棒，人品都没的说，团结互助，学习刻苦，工作认真积极，灵活上进。我几乎会把他们全部留下来，现在已有一多半安排了实际的工作，并取得了很好的成绩。等他们出徒之日，凭他们的能力一定能够拿到高薪，而且我还承诺过一个徒弟，当他拿到大学毕
    

    • 

  • linux expect
heipark
expect

    1. 创建、编辑文件go.sh
 
#!/usr/bin/expect
spawn sudo su admin
expect "*password*" { send "13456\r\n" }
interact
   2. 设置权限
  chmod u+x go.sh  3.
    

    • 

  • Spring4.1新特性——静态资源处理增强
jinnianshilongnian
spring 4.1

    目录
Spring4.1新特性——综述
Spring4.1新特性——Spring核心部分及其他
Spring4.1新特性——Spring缓存框架增强
Spring4.1新特性——异步调用和事件机制的异常处理
Spring4.1新特性——数据库集成测试脚本初始化
Spring4.1新特性——Spring MVC增强
Spring4.1新特性——页面自动化测试框架Spring MVC T
    

    • 

  • idea ubuntuxia 乱码
liyonghui160com

     
1.首先需要在windows字体目录下或者其它地方找到simsun.ttf 这个 字体文件。
2.在ubuntu 下可以执行下面操作安装该字体：
sudo mkdir /usr/share/fonts/truetype/simsun
sudo cp simsun.ttf /usr/share/fonts/truetype/simsun
fc-cache -f -v

    

    • 

  • 改良程序的11技巧
pda158
技巧

    有很多理由都能说明为什么我们应该写出清晰、可读性好的程序。最重要的一点，程序你只写一次，但以后会无数次的阅读。当你第二天回头来看你的代码 时，你就要开始阅读它了。当你把代码拿给其他人看时，他必须阅读你的代码。因此，在编写时多花一点时间，你会在阅读它时节省大量的时间。
 
让我们看一些基本的编程技巧：
 
尽量保持方法简短
永远永远不要把同一个变量用于多个不同的
    

    • 

  • 300个涵盖IT各方面的免费资源（下）——工作与学习篇
shoothao
创业免费资源学习课程远程工作

    工作与生产效率:
 
A. 背景声音
Noisli:背景噪音与颜色生成器。
Noizio:环境声均衡器。
Defonic:世界上任何的声响都可混合成美丽的旋律。
Designers.mx:设计者为设计者所准备的播放列表。
Coffitivity:这里的声音就像咖啡馆里放的一样。
B. 避免注意力分散
Self Co
    

    • 

  • 深入浅出RPC
uule
rpc

    深入浅出RPC-浅出篇
深入浅出RPC-深入篇
 
RPC
Remote Procedure Call Protocol
远程过程调用协议
 
它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。RPC协议假定某些传输协议的存在，如TCP或UDP，为通信程序之间携带信息数据。在OSI网络通信模型中，RPC跨越了传输层和应用层。RPC使得开发
    

    •