addBatch怎么使用，用个例子

可以使用以下代码示例来使用addBatch方法：

// 假设我们有一个名为"users"的表格，包含"id"和"name"两列
String sql = "INSERT INTO users (id, name) VALUES (?, ?)";
PreparedStatement statement = connection.prepareStatement(sql);

// 添加第一行数据
statement.setInt(1, 1);
statement.setString(2, "Alice");
statement.addBatch();

// 添加第二行数据
statement.setInt(1, 2);
statement.setString(2, "Bob");
statement.addBatch();

// 执行批量操作
int[] result = statement.executeBatch();

在上面的代码中，我们首先创建了一个PreparedStatement对象，并设置了SQL语句。然后，我们使用setInt和setString方法设置了第一行数据的参数，并使用addBatch方法将其添加到批处理中。接着，我们重复这个过程，将第二行数据也添加到批处理中。最后，我们调用executeBatch方法执行批处理，并将结果存储在一个整数数组中。

相关问题

oracle数据库 在多线程批量插入数据库时 会不会产生问题？如何解决？举个例子说明

Oracle数据库在多线程批量插入数据时可能会遇到一些问题，尤其是在并发访问量较大、网络延迟较高或数据库资源紧张的情况下。这些问题主要包括：

1. 数据一致性：如果多个线程同时操作同一张表的同一批次数据，如果没有适当的锁机制，可能导致数据冲突，例如部分插入失败或者数据重复。

2. 并发控制：Oracle的事务隔离级别影响并发性能，如果不恰当设置，可能会导致脏读、不可重复读或幻读等问题。

3. 资源争抢：多个线程可能争夺数据库连接，若连接池不足，可能导致某个线程阻塞直到其他线程释放连接。

为了解决这些问题，可以采取以下几个措施：

1. 使用批处理（Batching）：将多条SQL语句组织成一个批次提交，减少对数据库的频繁交互，提高效率。

BEGIN;
INSERT INTO table VALUES (value1, value2);
... 更多插入语句 ...
COMMIT;

2. 适当设置并发控制：调整Oracle的事务隔离级别，比如使用READ COMMITTED保证一致性，避免脏读。也可以考虑使用乐观锁定（Row Level Locking）或者分布式锁来防止数据竞争。

3. 线程同步：使用锁（如行级锁、共享锁或悲观锁）保护敏感操作，确保同一时间只有一个线程能更新数据。

4. 使用连接池：管理数据库连接，避免线程频繁申请和释放连接，提高资源利用率。

5. 批量插入优化：对于大表，可以考虑使用BULK INSERT命令，它会一次性将大量数据插入到表中，进一步提升性能。

例如，假设我们有三个线程同时尝试插入数据：

public class DataInsertThread implements Runnable {
    private Connection conn;
    private PreparedStatement pstmt;

    @Override
    public void run() {
        try {
            // 连接到数据库
            pstmt = conn.prepareStatement("INSERT INTO my_table VALUES (?, ?)");
            
            // 启动批处理
            while (!isDone()) {
                pstmt.addBatch();
                
                // ... 从队列获取更多数据并添加到批处理中 ...
            }
            
            // 提交所有批处理
            pstmt.executeBatch();
        } catch (SQLException e) {
            handleException(e);
        } finally {
            closeResources(pstmt, conn);
        }
    }

    private boolean isDone() { ... } // 判断是否已达到停止条件

    private void handleException(SQLException e) { ... } // 错误处理

    private void closeResources(PreparedStatement pstmt, Connection conn) {
        if (pstmt != null) pstmt.close();
        if (conn != null) try { conn.close(); } catch (SQLException ignored) {}
    }
}

// 创建连接池并分配连接给每个线程
ExecutorService executor = Executors.newFixedThreadPool(3);
for (int i = 0; i < 3; i++) {
    executor.submit(new DataInsertThread(connectionFromPool()));
}
executor.shutdown();

在这个例子中，每个线程都有自己的批处理语句，并在完成后再提交。通过线程同步和批量操作，我们可以减少并发插入时可能出现的问题。

shardingjdbc批量插入例子

以下是使用ShardingJDBC进行批量插入的示例代码：

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import org.apache.shardingsphere.api.sharding.standard.PreciseShardingAlgorithm;
import org.apache.shardingsphere.api.sharding.standard.RangeShardingAlgorithm;
import org.apache.shardingsphere.api.sharding.standard.StandardShardingStrategyConfiguration;
import org.apache.shardingsphere.driver.api.ShardingDataSourceFactory;
import org.apache.shardingsphere.shardingjdbc.api.ShardingDataSource;
import org.apache.shardingsphere.shardingjdbc.jdbc.core.datasource.ShardingDataSourceWrapper;
import org.apache.shardingsphere.shardingjdbc.jdbc.core.statement.ShardingPreparedStatement;
import org.apache.shardingsphere.shardingjdbc.jdbc.core.statement.ShardingStatement;

import com.alibaba.druid.pool.DruidDataSource;

public class ShardingJDBCBatchInsertExample {

    public static void main(String[] args) throws SQLException {

        // 配置分库
        List<DruidDataSource> dataSourceList = new ArrayList<>();
        for (int i = 0; i < 2; i++) {
            DruidDataSource dataSource = new DruidDataSource();
            dataSource.setDriverClassName("com.mysql.jdbc.Driver");
            dataSource.setUrl("jdbc:mysql://localhost:3306/db" + i + "?serverTimezone=UTC&useSSL=false");
            dataSource.setUsername("root");
            dataSource.setPassword("root");
            dataSourceList.add(dataSource);
        }

        // 配置分表
        PreciseShardingAlgorithm<Long> preciseShardingAlgorithm = (databaseNames, shardingValue) -> {
            for (String each : databaseNames) {
                if (each.endsWith(shardingValue.getValue() % 2 + "")) {
                    return each;
                }
            }
            throw new UnsupportedOperationException();
        };

        RangeShardingAlgorithm<Long> rangeShardingAlgorithm = (databaseNames, shardingValue) -> {
            List<String> result = new ArrayList<>();
            Long lowerValue = shardingValue.getValueRange().lowerEndpoint();
            Long upperValue = shardingValue.getValueRange().upperEndpoint();
            for (String each : databaseNames) {
                String value = each.substring(each.length() - 1);
                Long intValue = Long.parseLong(value);
                if (intValue >= lowerValue && intValue <= upperValue) {
                    result.add(each);
                }
            }
            return result;
        };

        StandardShardingStrategyConfiguration databaseShardingStrategyConfiguration = new StandardShardingStrategyConfiguration("id", preciseShardingAlgorithm, rangeShardingAlgorithm);
        ShardingDataSource shardingDataSource = ShardingDataSourceFactory.createDataSource(dataSourceList, Collections.singleton(databaseShardingStrategyConfiguration), new Properties());

        // 执行批量插入
        Connection conn = shardingDataSource.getConnection();
        String sql = "insert into t_order (id, user_id, status) values (?, ?, ?)";
        ShardingPreparedStatement pstmt = (ShardingPreparedStatement) conn.prepareStatement(sql);
        for (int i = 1; i <= 100; i++) {
            pstmt.setLong(1, i);
            pstmt.setLong(2, i % 10);
            pstmt.setString(3, "INIT");
            pstmt.addBatch();
        }
        pstmt.executeBatch();

        conn.close();
    }
}

该示例代码中，我们首先配置了两个Druid数据源，分别对应两个数据库db0和db1。然后，我们使用PreciseShardingAlgorithm和RangeShardingAlgorithm两种算法配置分库分表策略。具体而言，我们根据订单ID（id）的值来判断该订单属于哪个数据库和表，其中id % 2的值为0时，订单会被分配到db0数据库，否则分配到db1数据库；对于每个数据库，我们又根据id值的范围来判断该订单属于哪个表。

在执行批量插入时，我们首先通过shardingDataSource.getConnection()方法获取一个连接。然后，我们构造一个PreparedStatement对象，设置好参数，调用addBatch()方法将数据加入批处理队列中，最后调用executeBatch()方法执行批处理操作。由于使用了ShardingJDBC，ShardingPreparedStatement对象会在内部根据id值的分片规则自动将订单插入到对应的数据库和表中。