Sharding-Jdbc执行引擎准备阶段源码分析

充电ings

已于 2022-01-30 11:27:03 修改

阅读量1.5k

点赞数

分类专栏： sharding-jdbc 文章标签： java

于 2022-01-30 11:25:12 首次发布

本文链接：https://blog.csdn.net/qq_37402304/article/details/122750135

版权

sharding-jdbc 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

前言

在使用sharding-jdbc4.1.1过程中，遇到了死锁的情况，是由：执行引擎在准备阶段多创建一个connection引起的。所以对准备阶段的源码分析了解一下。

官方对准备阶段的描述文档：

https://shardingsphere.apache.org/document/4.1.1/cn/features/sharding/principle/execute/

准备阶段

顾名思义，此阶段用于准备执行的数据。它分为结果集分组和执行单元创建两个步骤。

结果集分组是实现内化连接模式概念的关键。执行引擎根据maxConnectionSizePerQuery配置项，结合当前路由结果，选择恰当的连接模式。具体步骤如下：

将SQL的路由结果按照数据源的名称进行分组。
通过下图的公式，可以获得每个数据库实例在maxConnectionSizePerQuery的允许范围内，每个连接需要执行的SQL路由结果组，并计算出本次请求的最优连接模式。

在maxConnectionSizePerQuery允许的范围内，当一个连接需要执行的请求数量大于1时，意味着当前的数据库连接无法持有相应的数据结果集，则必须采用内存归并；反之，当一个连接需要执行的请求数量等于1时，意味着当前的数据库连接可以持有相应的数据结果集，则可以采用流式归并。

每一次的连接模式的选择，是针对每一个物理数据库的。也就是说，在同一次查询中，如果路由至一个以上的数据库，每个数据库的连接模式不一定一样，它们可能是混合存在的形态。

通过上一步骤获得的路由分组结果创建执行的单元。当数据源使用数据库连接池等控制数据库连接数量的技术时，在获取数据库连接时，如果不妥善处理并发，则有一定几率发生死锁。在多个请求相互等待对方释放数据库连接资源时，将会产生饥饿等待，造成交叉的死锁问题。

举例说明，假设一次查询需要在某一数据源上获取两个数据库连接，并路由至同一个数据库的两个分表查询。则有可能出现查询A已获取到该数据源的1个数据库连接，并等待获取另一个数据库连接；而查询B也已经在该数据源上获取到的一个数据库连接，并同样等待另一个数据库连接的获取。如果数据库连接池的允许最大连接数是2，那么这2个查询请求将永久的等待下去。下图描绘了死锁的情况。
在这里插入图片描述
ShardingSphere为了避免死锁的出现，在获取数据库连接时进行了同步处理。它在创建执行单元时，以原子性的方式一次性获取本次SQL请求所需的全部数据库连接，杜绝了每次查询请求获取到部分资源的可能。由于对数据库的操作非常频繁，每次获取数据库连接时时都进行锁定，会降低ShardingSphere的并发。因此，ShardingSphere在这里进行了2点优化：

避免锁定一次性只需要获取1个数据库连接的操作。因为每次仅需要获取1个连接，则不会发生两个请求相互等待的场景，无需锁定。对于大部分OLTP的操作，都是使用分片键路由至唯一的数据节点，这会使得系统变为完全无锁的状态，进一步提升了并发效率。除了路由至单分片的情况，读写分离也在此范畴之内。
仅针对内存限制模式时才进行资源锁定。在使用连接限制模式时，所有的查询结果集将在装载至内存之后释放掉数据库连接资源，因此不会产生死锁等待的问题。

（这里的死锁场景跟我上一篇遇到的场景是不同的：https://blog.csdn.net/qq_37402304/article/details/122743074）

源码：

准备阶段的调用栈：

在这里插入图片描述

public final class ShardingPreparedStatement extends AbstractShardingPreparedStatementAdapter {
	.............
    /**
     * 执行
     */
    @Override
    public boolean execute() throws SQLException {
        try {
            clearPrevious();
            prepare();
            initPreparedStatementExecutor();
            return preparedStatementExecutor.execute();
        } finally {
            clearBatch();
        }
    }
    
    /**
     * 准备阶段
     */
    private void initPreparedStatementExecutor() throws SQLException {
        preparedStatementExecutor.init(executionContext);
        setParametersForStatements();
        replayMethodForStatements();
    }
    .................
}

public final class PreparedStatementExecutor extends AbstractStatementExecutor {
    
   ..............................
    
    /**
     * Initialize executor.
     *
     * @param executionContext execution context
     * @throws SQLException SQL exception
     */
    public void init(final ExecutionContext executionContext) throws SQLException {
        setSqlStatementContext(executionContext.getSqlStatementContext());
        getInputGroups().addAll(obtainExecuteGroups(executionContext.getExecutionUnits()));
        cacheStatements();
    }
    
    /**
     * 获得执行的单元组
     *
     * @param executionUnits
     * @return
     * @throws SQLException
     */
    private Collection<InputGroup<StatementExecuteUnit>> obtainExecuteGroups(final Collection<ExecutionUnit> executionUnits) throws SQLException {
    	//getExecuteUnitGroups 开始准备阶段
        return getSqlExecutePrepareTemplate().getExecuteUnitGroups(executionUnits, new SQLExecutePrepareCallback() {
            
            @Override
            public List<Connection> getConnections(final ConnectionMode connectionMode, final String dataSourceName, final int connectionSize) throws SQLException {
                return PreparedStatementExecutor.super.getConnection().getConnections(connectionMode, dataSourceName, connectionSize);
            }
            
            @Override
            public StatementExecuteUnit createStatementExecuteUnit(final Connection connection, final ExecutionUnit executionUnit, final ConnectionMode connectionMode) throws SQLException {
                return new StatementExecuteUnit(executionUnit, createPreparedStatement(connection, executionUnit.getSqlUnit().getSql()), connectionMode);
            }
        });
    }
    ....................
}

@RequiredArgsConstructor
public final class SQLExecutePrepareTemplate {

    /**
     * 受{@link org.apache.shardingsphere.underlying.common.config.properties.ConfigurationPropertyKey#MAX_CONNECTIONS_SIZE_PER_QUERY}控制
     * maxConnectionsSizePerQuery:该参数表示一次查询时每个数据库所允许使用的最大连接数。
     */
    private final int maxConnectionsSizePerQuery;

    /**
     * Get execute unit groups.
     *
     * @param executionUnits execution units
     * @param callback SQL execute prepare callback
     * @return statement execute unit groups
     * @throws SQLException SQL exception
     */
    public Collection<InputGroup<StatementExecuteUnit>> getExecuteUnitGroups(final Collection<ExecutionUnit> executionUnits, final SQLExecutePrepareCallback callback) throws SQLException {
        return getSynchronizedExecuteUnitGroups(executionUnits, callback);
    }

    /**
     * 获得每个数据库实例在maxConnectionSizePerQuery的允许范围内，
     * 每个连接需要执行的SQL路由结果组，并计算出本次请求的最优连接模式。
     *
     * @param executionUnits SQL的路由结果
     * @param callback
     * @return
     * @throws SQLException
     */
    private Collection<InputGroup<StatementExecuteUnit>> getSynchronizedExecuteUnitGroups(
            final Collection<ExecutionUnit> executionUnits, final SQLExecutePrepareCallback callback) throws SQLException {
        Map<String, List<SQLUnit>> sqlUnitGroups = getSQLUnitGroups(executionUnits);
        Collection<InputGroup<StatementExecuteUnit>> result = new LinkedList<>();
        for (Entry<String, List<SQLUnit>> entry : sqlUnitGroups.entrySet()) {
            result.addAll(getSQLExecuteGroups(entry.getKey(), entry.getValue(), callback));
        }
        return result;
    }

    /**
     * 将SQL的路由结果按照数据源的名称进行分组
     *
     * @param executionUnits SQL的路由结果
     * @return
     */
    private Map<String, List<SQLUnit>> getSQLUnitGroups(final Collection<ExecutionUnit> executionUnits) {
        Map<String, List<SQLUnit>> result = new LinkedHashMap<>(executionUnits.size(), 1);
        for (ExecutionUnit each : executionUnits) {
            if (!result.containsKey(each.getDataSourceName())) {
                result.put(each.getDataSourceName(), new LinkedList<>());
            }
            result.get(each.getDataSourceName()).add(each.getSqlUnit());
        }
        return result;
    }

    /**
     * 获得每个连接需要执行的SQL路由结果组，并计算出本次请求的最优连接模式。
     * InputGroup里的List是：单个连接需要执行的SQL路由结果组
     *
     * @param dataSourceName
     * @param sqlUnits       路由、改写后的sql集合，如果sql语句里，分片键 in ()，那么会有多个分表的sql
     * @param callback       PreparedStatementExecutor里的匿名内部类
     * @return
     * @throws SQLException
     */
    private List<InputGroup<StatementExecuteUnit>> getSQLExecuteGroups(final String dataSourceName,
                                                                       final List<SQLUnit> sqlUnits, final SQLExecutePrepareCallback callback) throws SQLException {
        List<InputGroup<StatementExecuteUnit>> result = new LinkedList<>();
        // desiredPartitionSize:一共maxConnectionsSizePerQuery个分区,希望每个分区里的sql数量
        // 看sql的数量 是否 是maxConnectionsSizePerQuery的倍数，保证maxConnectionsSizePerQuery数量内，对sqlUnits均分
        // yes:每个分区的元素数量都一样; no:按desiredPartitionSize数量、依次的分隔
        int desiredPartitionSize = Math.max(0 == sqlUnits.size() % maxConnectionsSizePerQuery ? sqlUnits.size() / maxConnectionsSizePerQuery : sqlUnits.size() / maxConnectionsSizePerQuery + 1, 1);
        // 把sqlUnits分隔，按desiredPartitionSize数量、依次的分隔
        // 主要用途：用maxConnectionsSizePerQuery个connection来 并发执行 分区里的sql
        List<List<SQLUnit>> sqlUnitPartitions = Lists.partition(sqlUnits, desiredPartitionSize);
        // 连接模式。
        ConnectionMode connectionMode = maxConnectionsSizePerQuery < sqlUnits.size() ? ConnectionMode.CONNECTION_STRICTLY : ConnectionMode.MEMORY_STRICTLY;
        // 需要sqlUnitPartitions.size()个connection,实际 sqlUnitPartitions.size() <= maxConnectionsSizePerQuery
        List<Connection> connections = callback.getConnections(connectionMode, dataSourceName, sqlUnitPartitions.size());
        int count = 0;
        for (List<SQLUnit> each : sqlUnitPartitions) {
            result.add(getSQLExecuteGroup(connectionMode, connections.get(count++), dataSourceName, each, callback));
        }
        return result;
    }

    /**
     * 获得sql的执行组：把分区内的sql，组装到StatementExecuteUnit对象
     *
     * @param connectionMode
     * @param connection
     * @param dataSourceName
     * @param sqlUnitGroup 分区里的sql语句组
     * @param callback
     * @return
     * @throws SQLException
     */
    private InputGroup<StatementExecuteUnit> getSQLExecuteGroup(final ConnectionMode connectionMode, final Connection connection,
                                                                final String dataSourceName, final List<SQLUnit> sqlUnitGroup,
                                                                final SQLExecutePrepareCallback callback) throws SQLException {
        List<StatementExecuteUnit> result = new LinkedList<>();
        for (SQLUnit each : sqlUnitGroup) {
            result.add(callback.createStatementExecuteUnit(connection, new ExecutionUnit(dataSourceName, each), connectionMode));
        }
        return new InputGroup<>(result);
    }
}

public abstract class AbstractConnectionAdapter extends AbstractUnsupportedOperationConnection {
    
    /**
     * Get database connection.
     *
     * @param dataSourceName data source name
     * @return database connection
     * @throws SQLException SQL exception
     */
    public final Connection getConnection(final String dataSourceName) throws SQLException {
        return getConnections(ConnectionMode.MEMORY_STRICTLY, dataSourceName, 1).get(0);
    }
    
    /**
     * Get database connections. 获得数据库连接
     *
     * @param connectionMode connection mode  连接模式
     * @param dataSourceName data source name 数据源名称
     * @param connectionSize size of connection list to be get 目标连接数
     * @return database connections
     * @throws SQLException SQL exception
     */
    public final List<Connection> getConnections(final ConnectionMode connectionMode, final String dataSourceName, final int connectionSize) throws SQLException {
        DataSource dataSource = getDataSourceMap().get(dataSourceName);
        Preconditions.checkState(null != dataSource, "Missing the data source name: '%s'", dataSourceName);
        Collection<Connection> connections;
        // 先从缓存里获取
        synchronized (cachedConnections) {
            connections = cachedConnections.get(dataSourceName);
        }
        List<Connection> result;
        // 缓存里足够，直接返回
        if (connections.size() >= connectionSize) {
            result = new ArrayList<>(connections).subList(0, connectionSize);
        } else if (!connections.isEmpty()) {
            // 如果连接数小于目标数量，且缓存里非空 -> 那么新建（目标数-已有数）个连接
            result = new ArrayList<>(connectionSize);
            result.addAll(connections);
            List<Connection> newConnections = createConnections(dataSourceName, connectionMode, dataSource, connectionSize - connections.size());
            result.addAll(newConnections);
            synchronized (cachedConnections) {
                cachedConnections.putAll(dataSourceName, newConnections);
            }
        } else {
            // 如果连接数小于目标数量，且缓存是空的 -> 那么新建目标数个连接
            result = new ArrayList<>(createConnections(dataSourceName, connectionMode, dataSource, connectionSize));
            synchronized (cachedConnections) {
                cachedConnections.putAll(dataSourceName, result);
            }
        }
        return result;
    }

    /**
     *
     * @param dataSourceName
     * @param connectionMode 连接模式
     * @param dataSource
     * @param connectionSize 目标连接数
     * @return
     * @throws SQLException
     */
    @SuppressWarnings("SynchronizationOnLocalVariableOrMethodParameter")
    private List<Connection> createConnections(final String dataSourceName, final ConnectionMode connectionMode,
                                               final DataSource dataSource, final int connectionSize) throws SQLException {
        if (1 == connectionSize) {
            Connection connection = createConnection(dataSourceName, dataSource);
            replayMethodsInvocation(connection);
            return Collections.singletonList(connection);
        }
        // 连接限制模式下，
        if (ConnectionMode.CONNECTION_STRICTLY == connectionMode) {
            return createConnections(dataSourceName, dataSource, connectionSize);
        }
        // 内存限制模式下，控制并发
        // 对内存限制模式，ShardingSphere为了避免死锁的出现，在获取数据库连接时进行了同步处理。
        synchronized (dataSource) {
            return createConnections(dataSourceName, dataSource, connectionSize);
        }
    }

    /**
     * 获得目标数量的连接
     * @param dataSourceName
     * @param dataSource
     * @param connectionSize
     * @return
     * @throws SQLException
     */
    private List<Connection> createConnections(final String dataSourceName, final DataSource dataSource, final int connectionSize) throws SQLException {
        List<Connection> result = new ArrayList<>(connectionSize);
        for (int i = 0; i < connectionSize; i++) {
            try {
                Connection connection = createConnection(dataSourceName, dataSource);
                replayMethodsInvocation(connection);
                result.add(connection);
            } catch (final SQLException ex) {
                for (Connection each : result) {
                    each.close();
                }
                throw new SQLException(String.format("Could't get %d connections one time, partition succeed connection(%d) have released!", connectionSize, result.size()), ex);
            }
        }
        return result;
    }

    /**
     * 创建connection
     * @param dataSourceName
     * @param dataSource
     * @return
     * @throws SQLException
     */
    protected abstract Connection createConnection(String dataSourceName, DataSource dataSource) throws SQLException;

	..........................
}

充电ings

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Sharding-Jdbc执行引擎准备阶段源码分析

前言在使用sharding-jdbc4.1.1过程中，遇到了死锁的情况，是由：执行引擎在准备阶段多创建一个connection引起的。所以对准备阶段的源码分析了解一下。官方对准备阶段的描述文档：https://shardingsphere.apache.org/document/4.1.1/cn/features/sharding/principle/execute/准备阶段顾名思义，此阶段用于准备执行的数据。它分为结果集分组和执行单元创建两个步骤。结果集分组是实现内化连接模式概念的关键。执行引
复制链接

扫一扫