java怎么用多线程查询数据库进行数据汇总

在Java中使用多线程查询数据库进行数据汇总，可以采用以下步骤：

1. 导入相关的库，如 java.sql、java.util.concurrent。

2. 创建一个数据库连接池，用于多线程共享数据库连接。

3. 定义一个查询任务类，该类实现 Runnable 接口，用于执行查询并将查询结果保存到共享的数据结构中。

4. 创建多个查询任务对象，并将它们添加到线程池中。

5. 等待所有查询任务完成，并汇总结果。

以下是一个简单的示例代码：

import java.sql.*;
import java.util.concurrent.*;

public class Main {
    // 创建数据库连接池
    static BlockingQueue<Connection> dbPool = new ArrayBlockingQueue<>(10);
    static {
        try {
            for (int i = 0; i < 10; i++) {
                Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "password");
                dbPool.put(conn);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 定义查询任务类
    static class QueryTask implements Runnable {
        String queryStr;
        ConcurrentMap<String, Integer> resultMap;

        public QueryTask(String queryStr, ConcurrentMap<String, Integer> resultMap) {
            this.queryStr = queryStr;
            this.resultMap = resultMap;
        }

        @Override
        public void run() {
            Connection conn = null;
            Statement stmt = null;
            ResultSet rs = null;
            try {
                // 从连接池中获取连接
                conn = dbPool.take();
                stmt = conn.createStatement();
                rs = stmt.executeQuery(queryStr);

                // 处理查询结果
                while (rs.next()) {
                    String key = rs.getString("key");
                    int value = rs.getInt("value");
                    resultMap.merge(key, value, Integer::sum);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    if (rs != null) rs.close();
                    if (stmt != null) stmt.close();
                    if (conn != null) dbPool.put(conn);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws Exception {
        // 创建多个查询任务
        String[] queries = {"SELECT * FROM table1", "SELECT * FROM table2", "SELECT * FROM table3"};
        ConcurrentMap<String, Integer> resultMap = new ConcurrentHashMap<>();
        ExecutorService executor = Executors.newFixedThreadPool(10);
        for (String queryStr : queries) {
            QueryTask task = new QueryTask(queryStr, resultMap);
            executor.execute(task);
        }

        // 等待所有查询任务完成
        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.MINUTES);

        // 汇总结果
        for (String key : resultMap.keySet()) {
            int value = resultMap.get(key);
            System.out.println(key + ": " + value);
        }
    }
}

在这个示例代码中，我们使用了一个 ConcurrentMap 对象来保存查询结果，它是一个线程安全的哈希表，可以在多线程环境下进行并发访问。在每个查询任务中，我们从数据库连接池中获取一个数据库连接，执行查询，并将查询结果保存到 ConcurrentMap 对象中。最后，我们使用 ExecutorService 线程池来执行查询任务，并等待所有任务完成后汇总结果。