请给我一个List集合使用多线程的方式分批插入数据的Java代码

可以使用如下的Java代码来实现：List list = new ArrayList();
int maxThreadCount = 10;
ExecutorService executorService = Executors.newFixedThreadPool(maxThreadCount);

int batchSize = 1000;
int listSize = list.size();
int threadCount = listSize/batchSize + (listSize%batchSize > 0 ? 1 : 0);

for(int i=0; i<threadCount; i++){
int startIndex = i * batchSize;
int endIndex = (i+1) * batchSize;
endIndex = endIndex > listSize ? listSize : endIndex;
Runnable runnable = new BatchInsertRunnable(list,startIndex, endIndex);
executorService.execute(runnable);
}

executorService.shutdown();
while(!executorService.isTerminated()){
//wait for all thread to finish
}

相关问题

请帮我实现使用多线程进行数据库插入大量数据的java代码

好的，以下是使用多线程进行数据库插入大量数据的Java代码示例：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class InsertDataMultiThread {
    private static final String DB_DRIVER = "com.mysql.jdbc.Driver";
    private static final String DB_CONNECTION = "jdbc:mysql://localhost:3306/mydatabase";
    private static final String DB_USER = "root";
    private static final String DB_PASSWORD = "password";

    private static final int THREAD_POOL_SIZE = 10;
    private static final int BATCH_SIZE = 1000;

    public static void main(String[] args) {
        Connection dbConnection = null;

        try {
            // 获取数据库连接
            dbConnection = getDBConnection();

            // 设置自动提交为 false
            dbConnection.setAutoCommit(false);

            // 创建一个线程池
            ExecutorService executor = Executors.newFixedThreadPool(THREAD_POOL_SIZE);

            // 创建一个 PreparedStatement 对象
            PreparedStatement preparedStatement = dbConnection.prepareStatement("INSERT INTO mytable (col1, col2, col3) VALUES (?, ?, ?)");

            // 构造数据列表
            List<Data> dataList = new ArrayList<>();
            for (int i = 0; i < 1000000; i++) {
                Data data = new Data("value1", "value2", "value3");
                dataList.add(data);
            }

            // 将数据列表分割成多个批次
            List<List<Data>> batches = splitIntoBatches(dataList, BATCH_SIZE);

            // 依次将每个批次提交到线程池中执行
            for (List<Data> batch : batches) {
                Runnable task = new InsertDataTask(preparedStatement, batch);
                executor.execute(task);
            }

            // 关闭线程池
            executor.shutdown();

            // 等待所有任务执行完毕
            while (!executor.isTerminated()) {}

            // 提交事务
            dbConnection.commit();

            System.out.println("Data inserted successfully.");
        } catch (SQLException e) {
            System.err.println(e.getMessage());
        } finally {
            try {
                if (dbConnection != null) {
                    // 恢复自动提交
                    dbConnection.setAutoCommit(true);

                    // 关闭数据库连接
                    dbConnection.close();
                }
            } catch (SQLException e) {
                System.err.println(e.getMessage());
            }
        }
    }

    private static Connection getDBConnection() throws SQLException {
        Connection dbConnection = null;
        try {
            Class.forName(DB_DRIVER);
        } catch (ClassNotFoundException e) {
            System.err.println(e.getMessage());
        }
        dbConnection = DriverManager.getConnection(DB_CONNECTION, DB_USER, DB_PASSWORD);
        return dbConnection;
    }

    private static <T> List<List<T>> splitIntoBatches(List<T> list, int batchSize) {
        List<List<T>> batches = new ArrayList<>();
        int size = list.size();
        for (int i = 0; i < size; i += batchSize) {
            batches.add(list.subList(i, Math.min(size, i + batchSize)));
        }
        return batches;
    }

    private static class InsertDataTask implements Runnable {
        private PreparedStatement preparedStatement;
        private List<Data> dataList;

        public InsertDataTask(PreparedStatement preparedStatement, List<Data> dataList) {
            this.preparedStatement = preparedStatement;
            this.dataList = dataList;
        }

        @Override
        public void run() {
            try {
                for (Data data : dataList) {
                    preparedStatement.setString(1, data.getCol1());
                    preparedStatement.setString(2, data.getCol2());
                    preparedStatement.setString(3, data.getCol3());
                    preparedStatement.addBatch();
                }
                preparedStatement.executeBatch();
            } catch (SQLException e) {
                System.err.println(e.getMessage());
            }
        }
    }

    private static class Data {
        private String col1;
        private String col2;
        private String col3;

        public Data(String col1, String col2, String col3) {
            this.col1 = col1;
            this.col2 = col2;
            this.col3 = col3;
        }

        public String getCol1() {
            return col1;
        }

        public void setCol1(String col1) {
            this.col1 = col1;
        }

        public String getCol2() {
            return col2;
        }

        public void setCol2(String col2) {
            this.col2 = col2;
        }

        public String getCol3() {
            return col3;
        }

        public void setCol3(String col3) {
            this.col3 = col3;
        }
    }
}

在这个示例代码中，我们使用了线程池来并发执行大量的数据库插入操作。每个线程负责将一个批次的数据插入到数据库中。我们将数据列表分割成多个批次，每个批次的大小为 BATCH_SIZE，然后依次将每个批次提交到线程池中执行。在每个线程中，我们使用 PreparedStatement 对象来执行批量插入操作，可以有效地减少数据库连接和交互的次数。当所有任务执行完毕后，我们提交事务并关闭数据库连接。

如果你想要使用这个示例代码，需要将 DB_CONNECTION、DB_USER 和 DB_PASSWORD 替换成你自己的数据库连接信息，同时需要创建一个名为 mytable 的表，并且包含三个文本列 col1、col2 和 col3。

java实现使用线程池多线程分页插入数据

好的，下面是使用线程池多线程分页插入数据的 Java 代码示例：

首先，我们需要定义一个线程池，并设置最大线程数为 10：

ExecutorService executorService = Executors.newFixedThreadPool(10);

接下来，我们需要获取总记录数，以及每页的记录数和总页数：

int totalNum = getTotalNum(); // 获取总记录数
int pageSize = 100; // 每页的记录数
int pageNum = totalNum % pageSize == 0 ? totalNum / pageSize : totalNum / pageSize + 1; // 总页数

然后，我们可以使用循环来遍历每一页，并提交任务给线程池：

for (int i = 1; i <= pageNum; i++) {
    final int currentPage = i;
    executorService.submit(new Runnable() {
        @Override
        public void run() {
            List<Data> dataList = getDataList(currentPage, pageSize); // 获取当前页的数据列表
            insertDataList(dataList); // 插入数据
        }
    });
}

在任务的 run 方法中，我们首先需要获取当前页的数据列表，然后调用插入数据的方法来插入数据：

public List<Data> getDataList(int currentPage, int pageSize) {
    // 根据当前页和每页的记录数查询数据
    // ...
}

public void insertDataList(List<Data> dataList) {
    // 插入数据
    // ...
}

最后，我们需要关闭线程池：

executorService.shutdown();

完整的代码示例：

ExecutorService executorService = Executors.newFixedThreadPool(10);

int totalNum = getTotalNum(); // 获取总记录数
int pageSize = 100; // 每页的记录数
int pageNum = totalNum % pageSize == 0 ? totalNum / pageSize : totalNum / pageSize + 1; // 总页数

for (int i = 1; i <= pageNum; i++) {
    final int currentPage = i;
    executorService.submit(new Runnable() {
        @Override
        public void run() {
            List<Data> dataList = getDataList(currentPage, pageSize); // 获取当前页的数据列表
            insertDataList(dataList); // 插入数据
        }
    });
}

executorService.shutdown();

需要注意的是，该示例仅是一个简单的示例，实际使用中还需要考虑一些细节问题，比如异常处理、分页查询的 SQL 语句等。