数据库中间件 Sharding-JDBC 源码分析 —— SQL 执行

1. 概述

越过千山万水（SQL 解析、SQL 路由、SQL 改写），我们终于来到了 SQL 执行。开森不开森？！

查询语句的程序入口为ShardingPreparedStatement#execute：

public boolean execute() throws SQLException {
        try {
            // 路由（包括了 SQL 解析、SQL 路由、SQL 改写）
            Collection preparedStatementUnits = route();
            // SQL 执行
            return new PreparedStatementExecutor(
                    getConnection().getShardingContext().getExecutorEngine(), routeResult.getSqlStatement().getType(), preparedStatementUnits, getParameters()).execute();
        } finally {
            clearBatch();
        }
    }

前面的文章已经讲了 SQL 解析、SQL 路由、SQL 改写，本文继续探讨 SQL 执行。

注意：之所以未采用常用的executeQuery，是因为它只支持返回一个结果集ResultSet，不符合分片的场景。

2. ExecutorEngine

ExecutorEngine，SQL执行引擎。

分表分库，需要执行的 SQL 数量从单条变成了多条，此时有两种方式执行：

• 串行执行 SQL
• 并行执行 SQL

前者，编码容易，性能较差，总耗时是多条 SQL 执行时间累加。
后者，编码复杂，性能较好，总耗时约等于执行时间最长的 SQL。

ExecutorEngine 当然采用的是后者，并行执行 SQL。

2.1 ListeningExecutorService

Guava( Java 工具库 ) 提供的继承自 ExecutorService 的线程服务接口，提供创建 ListenableFuture 功能。ListenableFuture 接口，继承 Future 接口，有如下好处：

我们强烈地建议你在代码中多使用 ListenableFuture 来代替 JDK 的 Future, 因为：
1. 大多数 Futures 方法中需要它。
2. 转到 ListenableFuture 编程比较容易。
3. Guava 提供的通用公共类封装了公共的操作方方法，不需要提供 Future 和 ListenableFuture 的扩展方法。

传统 JDK中 的 Future 通过异步的方式计算返回结果:在多线程运算中可能在没有结束就返回结果。

ListenableFuture 可以允许你注册回调方法(callbacks)，在运算（多线程执行）完成的时候进行调用。这样简单的改进，使得可以明显的支持更多的操作，这样的功能在 JDK concurrent 中的 Future 是不支持的。

下文我们看 Sharding-JDBC 是如何通过 ListenableFuture 简化并发编程的。

先看 ExecutorEngine 如何初始化 ListeningExecutorService：

public final class ExecutorEngine implements AutoCloseable {
    
    private final ListeningExecutorService executorService;
    
    public ExecutorEngine(final int executorSize) {
        executorService = MoreExecutors.listeningDecorator(new ThreadPoolExecutor(
                executorSize, executorSize, 0, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(), new ThreadFactoryBuilder().setDaemon(true).setNameFormat("ShardingJDBC-%d").build()));
        MoreExecutors.addDelayedShutdownHook(executorService, 60, TimeUnit.SECONDS);
    }
    ...
}

• 一个分片数据源( ShardingDataSource ) 独占 一个 SQL执行引擎( ExecutorEngine )。
• MoreExecutors#listeningDecorator()创建 ListeningExecutorService，这样 #submit()， #invokeAll() 可以返回 ListenableFuture。
• 默认情况下，线程池大小为 8。可以根据实际业务需要，设置 ShardingProperties 进行调整。
• setNameFormat()并发编程时，一定要对线程名字做下定义，这样排查问题会方便很多。
• MoreExecutors#addDelayedShutdownHook()，应用关闭时，等待所有任务全部完成再关闭。默认配置等待时间为 60 秒，建议将等待时间做成可配的。

2.2 关闭

数据源关闭时，会调用 ExecutorEngine 也进行关闭。

    // ShardingDataSource.java
    @Override
    public void close() {
       executorEngine.close();
    }

    // ExecutorEngine
    @Override
    public void close() {
       executorService.shutdownNow();
       try {
           executorService.awaitTermination(5, TimeUnit.SECONDS);
       } catch (final InterruptedException ignored) {
       }
       if (!executorService.isTerminated()) {
           throw new ShardingJdbcException("ExecutorEngine can not been terminated");
       }
    }

• shutdownNow() 尝试使用 Thread.interrupt() 打断正在执行中的任务，未执行的任务不再执行。
• awaitTermination() 因为 #shutdownNow() 打断不是立即结束，需要一个过程，因此这里等待了 5 秒。
• 等待 5 秒后，线程池不一定已经关闭，此时抛出异常给上层。建议打印下日志，记录出现这个情况。

2.3 执行 SQL 任务

ExecutorEngine 对外暴露executeStatement()， executePreparedStatement()， executeBatch()三个方法分别提供给 StatementExecutor、PreparedStatementExecutor、BatchPreparedStatementExecutor 调用。而这三个方法，内部调用的都是execute()私有方法。

// ExecutorEngine.java
private   List execute(
            final SQLType sqlType, final Collection baseStatementUnits, 
            final List> parameterSets, final ExecuteCallback executeCallback) throws SQLException {
        if (baseStatementUnits.isEmpty()) {
            return Collections.emptyList();
        }
        OverallExecutionEvent event = new OverallExecutionEvent(sqlType, baseStatementUnits.size());
        // 发布执行之前事件
        EventBusInstance.getInstance().post(event);
        Iterator iterator = baseStatementUnits.iterator();
        BaseStatementUnit firstInput = iterator.next();
        // 第二个任务开始所有 SQL任务 提交线程池【异步】执行任务
        ListenableFuture> restFutures = asyncExecute(sqlType, Lists.newArrayList(iterator), parameterSets, executeCallback);
        T firstOutput;
        List restOutputs;
        try {
            // 第一个任务【同步】执行任务
            firstOutput = syncExecute(sqlType, firstInput, parameterSets, executeCallback);
            // 等待第二个任务开始所有 SQL任务完成
            restOutputs = restFutures.get();
            //CHECKSTYLE:OFF
        } catch (final Exception ex) {
            //CHECKSTYLE:ON
            event.setException(ex);
            event.setEventExecutionType(EventExecutionType.EXECUTE_FAILURE);
            // 发布执行失败事件
            EventBusInstance.getInstance().post(event);
            ExecutorExceptionHandler.handleException(ex);
            return null;
        }
        event.setEventExecutionType(EventExecutionType.EXECUTE_SUCCESS);
        // 发布执行成功事件
        EventBusInstance.getInstance().post(event);
        // 返回结果
        List result = Lists.newLinkedList(restOutputs);
        result.add(0, firstOutput);
        return result;
    }

第一个任务【同步】调用executeInternal()执行任务。

    private  T syncExecute(final SQLType sqlType, final BaseStatementUnit baseStatementUnit, final List> parameterSets, final ExecuteCallback executeCallback) throws Exception {
       // 【同步】执行任务
       return executeInternal(sqlType, baseStatementUnit, parameterSets, executeCallback, ExecutorExceptionHandler.isExceptionThrown(), ExecutorDataMap.getDataMap());
    }

第二个开始的任务提交线程池异步调用executeInternal()执行任务。

private  ListenableFuture> asyncExecute(
            final SQLType sqlType, final Collection baseStatementUnits, final List> parameterSets, final ExecuteCallback executeCallback) {
        List> result = new ArrayList<>(baseStatementUnits.size());
        final boolean isExceptionThrown = ExecutorExceptionHandler.isExceptionThrown();
        final Map dataMap = ExecutorDataMap.getDataMap();
        for (final BaseStatementUnit each : baseStatementUnits) {
            // 提交线程池【异步】执行任务
            result.add(executorService.submit(new Callable() {
                
                @Override
                public T call() throws Exception {
                    return executeInternal(sqlType, each, parameterSets, executeCallback, isExceptionThrown, dataMap);
                }
            }));
        }
        // 返回 ListenableFuture
        return Futures.allAsList(result);
    }

我们注意下Futures.allAsList(result)和 restOutputs=restFutures.get()。神器 Guava 简化并发编程的好处就提现出来了。 ListenableFuture#get()当所有任务都成功时，返回所有任务执行结果；当任何一个任务失败时，马上抛出异常，无需等待其他任务执行完成。

为什么会分同步执行和异步执行呢？猜测，当 SQL 执行是单表时，只要进行第一个任务的同步调用，性能更加优秀。

// ExecutorEngine.java
private  T executeInternal(final SQLType sqlType, final BaseStatementUnit baseStatementUnit, final List> parameterSets, final ExecuteCallback executeCallback, 
                          final boolean isExceptionThrown, final Map dataMap) throws Exception {
        synchronized (baseStatementUnit.getStatement().getConnection()) {
            T result;
            ExecutorExceptionHandler.setExceptionThrown(isExceptionThrown);
            ExecutorDataMap.setDataMap(dataMap);
            List events = new LinkedList<>();
            if (parameterSets.isEmpty()) {
                // 生成 Event
                events.add(getExecutionEvent(sqlType, baseStatementUnit, Collections.emptyList()));
            }
            for (List