elasticsearch shard split 分析（三）

上篇文章分析了elasticsearch从接受到restful请求后怎么生成一个索引创建任务，接下来分析索引创建任务的执行过程。我们之前讲到在TieBreakingPrioritizedRunnable中实现了run方法，所以任务执行的时候肯定是先进入其run方法，那么就从它的run函数开始一步步分析。

TieBreakingPrioritizedRunnable

public void run() {
            synchronized (this) {
                // make the task as stared. This is needed for synchronization with the timeout handling
                // see  #scheduleTimeout()
                started = true;
                FutureUtils.cancel(timeoutFuture);
            }
            runAndClean(runnable);
        }

首先将started设置为true，表示任务开始执行。随后进入runAndClean方法。

private void runAndClean(Runnable run) {
            try {
                run.run();
            } finally {
                runnable = null;
                timeoutFuture = null;
            }

        }

这里调用了run的run方法，而run就是TieBreakingPrioritizedRunnable的runnable成员变量。那么该runnable对象是个什么类型的对象呢？还记得之前讲到执行command时会先对command包装一下吧，在那个包装函数里生成了PrioritizedEsThreadPoolExecutor对象，这里再次看下wrapRunnable函数。

protected Runnable wrapRunnable(Runnable command) {
        if (command instanceof PrioritizedRunnable) {
            if ((command instanceof TieBreakingPrioritizedRunnable)) {
                return command;
            }
            Priority priority = ((PrioritizedRunnable) command).priority();
            return new TieBreakingPrioritizedRunnable(super.wrapRunnable(command), priority, insertionOrder.incrementAndGet());
        } else if (command instanceof PrioritizedFutureTask) {
            return command;
        } else { // it might be a callable wrapper...
            if (command instanceof TieBreakingPrioritizedRunnable) {
                return command;
            }
            return new TieBreakingPrioritizedRunnable(super.wrapRunnable(command), Priority.NORMAL, insertionOrder.incrementAndGet());
        }
    }

可以看到在构造TieBreakingPrioritizedRunnable对象的再次调用了TieBreakingPrioritizedRunnable父类的wrapRunnable函数对command封装了一下。TieBreakingPrioritizedRunnable的父类为EsThreadPoolExecutor。

EsThreadPoolExecutor

protected Runnable wrapRunnable(Runnable command) {
        return contextHolder.preserveContext(command);
    }

这里调用了contextHolder的preserveContext函数。contextHolder是一个ThreadContext对象。

ThreadContext

public Runnable preserveContext(Runnable command) {
        if (command instanceof ContextPreservingAbstractRunnable) {
            return command;
        }
        if (command instanceof ContextPreservingRunnable) {
            return command;
        }
        if (command instanceof AbstractRunnable) {
            return new ContextPreservingAbstractRunnable((AbstractRunnable) command);
        }
        return new ContextPreservingRunnable(command);
    }

到这里最终返回的是ContextPreservingRunnable对象。所以回到TieBreakingPrioritizedRunnable的runAdnClean方法，此处的run对象就是ContextPreservingRunnable对象。

ContextPreservingRunnable

public void run() {
            boolean whileRunning = false;
            try (ThreadContext.StoredContext ignore = stashContext()){
                ctx.restore();
                whileRunning = true;
                in.run();
                whileRunning = false;
            } catch (IllegalStateException ex) {
                if (whileRunning || threadLocal.closed.get() == false) {
                    throw ex;
                }
                // if we hit an ISE here we have been shutting down
                // this comes from the threadcontext and barfs if
                // our threadpool has been shutting down
            }
        }

这里设置了一下context后就直接调用了in对象的run方法，这里的in成员就是最开始被包装的command，也就是UpdateTask对象，它属于BatchedTask的子类。

BatchedTask

public void run() {
            runIfNotProcessed(this);
        }

TaskBatcher

void runIfNotProcessed(BatchedTask updateTask) {
        // if this task is already processed, it shouldn't execute other tasks with same batching key that arrived later,
        // to give other tasks with different batching key a chance to execute.
        if (updateTask.processed.get() == false) {
            final List toExecute = new ArrayList<>();
            final Map> processTasksBySource = new HashMap<>();
            synchronized (tasksPerBatchingKey) {
                LinkedHashSet pending = tasksPerBatchingKey.remove(updateTask.batchingKey);
                if (pending != null) {
                    for (BatchedTask task : pending) {
                        if (task.processed.getAndSet(true) == false) {
                            logger.trace("will process {}", task);
                            toExecute.add(task);
                            processTasksBySource.computeIfAbsent(task.source, s -> new ArrayList<>()).add(task);
                        } else {
                            logger.trace("skipping {}, already processed", task);
                        }
                    }
                }
            }

            if (toExecute.isEmpty() == false) {
                final String tasksSummary = processTasksBySource.entrySet().stream().map(entry -> {
                    String tasks = updateTask.describeTasks(entry.getValue());
                    return tasks.isEmpty() ? entry.getKey() : entry.getKey() + "[" + tasks + "]";
                }).reduce((s1, s2) -> s1 + ", " + s2).orElse("");

                run(updateTask.batchingKey, toExecute, tasksSummary);
            }
        }
    }

这里先是计算哪些task需要被执行，随后调用run方法执行需要执行的task。

Batcher

protected void run(Object batchingKey, List tasks, String tasksSummary) {
            ClusterStateTaskExecutor