Java 计算网络上限和CPU上限：计算数据量以及将所有图像从DB传输到客户端的最短时间。然后尝试创建相同数量的空图像，并用伪值加载hashmap。较高的值将是您的限制。你无法超越这一点。与您当前的时间进行比较，检查是否值得花更多时间优化您的过程，或者您必须承受这一

---

计算网络上限和CPU上限：计算数据量以及将所有图像从DB传输到客户端的最短时间。然后尝试创建相同数量的空图像，并用伪值加载hashmap。较高的值将是您的限制。你无法超越这一点。与您当前的时间进行比较，检查是否值得花更多时间优化您的过程，或者您必须承受这一成本如果许多不同的连接使用相同的网络接口或相同的数据库实例，甚至是相同的网络设备（除非比链接快得多），那么读取这些连接上的数据是没有意义的。不管怎样，网络都将饱和。@Dariusz我们不能假设这一点。约翰说他有132克的内存，所以我想他没有一个小主机。据我所知，2014年最佳网络单链路的运行速度为255 TB/秒。而且很容易多路复用以太网链路以增加带宽。另一方面，我们对Jhon的Oracle体系结构一无所知（可能Jhon只有一个实例，也可能有一个网格系统——在这种情况下，使用一个连接与使用多个连接不同）。

id (long), img1 (blob),img2 (blob)...img10 (blob), created (date)

SELECT img1,img2,img3,... 
FROM images 
WHERE ID IN (SELECT ID FROM (SELECT A.*, ROWNUM RNUM FROM (SELECT ID FROM images) A 
WHERE ROWNUM <=end) WHERE RNUM >=start);

String url = ...your JDBC url
String user = ...your Oracle user
String pass = ...your password

int num_of_threads;
ParallelReader r = new ParallelReader(url, user, pass);
HashMap< Long, HashMap<Integer, byte[]>> map = r.read(num_of_threads);

import java.sql.Blob;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Level;
import java.util.logging.Logger;

class ParallelReader {

    private final String url;

    private final String user;

    private final String pass;

    public ParallelReader(String url, String user, String pass) {
        this.url = url;
        this.user = user;
        this.pass = pass;
    }

    public HashMap< Long, HashMap<Integer, byte[]>> read(int numthreads) {
        HashMap<Long, HashMap<Integer, byte[]>> unsafe_map = new HashMap<>();
        ConcurrentHashMap<Long, HashMap<Integer, byte[]>> safe_map = new ConcurrentHashMap<>(unsafe_map);

        Worker pool[] = new Worker[numthreads];
        for (int i = 0; i < numthreads; i++)
            pool[i] = new Worker(i, numthreads, safe_map);

        for (Worker w : pool)
            w.start();

        try {
            for (Worker w : pool)
                w.join();
        } catch (InterruptedException ex) {
            Logger.getLogger(ParallelReader.class.getName()).log(Level.SEVERE, null, ex);
        }

        return unsafe_map;
    }

    private class Worker extends Thread {

        private final long mod;

        private final long max;

        private final ConcurrentHashMap<Long, HashMap<Integer, byte[]>> safe_map;

        public Worker(long mod, long max, ConcurrentHashMap<Long, HashMap<Integer, byte[]>> safe_map) {
            this.mod = mod;
            this.max = max;
            this.safe_map = safe_map;
        }

        @Override
        public void run() {
            try (Connection conn = DriverManager.getConnection(url, user, pass)) {
                PreparedStatement pstmt = conn.prepareStatement(
                        "SELECT img1, img2, img3, img4, img5, img6, img7, img8, img9, img10, id "
                        + "FROM images "
                        + "WHERE MOD(id, ?) = ?");
                pstmt.setLong(1, max);
                pstmt.setLong(2, mod);
                ResultSet rset = pstmt.executeQuery();
                while (rset.next()) {
                    long id = rset.getLong(11);
                    HashMap<Integer, byte[]> imgs = new HashMap<>();
                    for (int i = 1; i <= 10; i++) {
                        Blob b = rset.getBlob(i);
                        byte bytes[] = b.getBytes((long) 1, (int) b.length());
                        imgs.put(i, bytes);
                    }
                    safe_map.put(id, imgs);
                }
            } catch (SQLException ex) {
                Logger.getLogger(ParallelReader.class.getName()).log(Level.SEVERE, null, ex);
            }
        }

    }

}