查询表的两个线程

Question

我有一个很大的表，大约1米的记录，我想对所有的记录做一些处理，所以1个线程的方式，就是说。。。1000条记录，处理它们，再获得1000条记录等等。。。但如果我想使用多任务处理呢？也就是说，两个线程分别获取1000条记录，并并行处理，如何确保每个线程将获取不同的1000条记录？注意：我正在使用hibernate

好像是这样的

public void run() {


    partList=getKParts(10);
    operateOnList(partList);


}

Answer 1

如果数据库中的记录确实具有类型为int或long的主键，则为每个线程添加一个限制，以便仅从范围中获取记录：

Thread1: 0000 - 0999, 2000 - 2999, etc
Thread2: 1000 - 1999, 3000 - 3999, etc

这样，每个线程只需要一个偏移量、一个计数器和一个增量。例如，Thread1的偏移量为0，而Thread2的偏移量为1000。由于本例中有两个线程，因此增量为2000。对于每轮增量，计算每个线程的计数器（从0开始），并计算下一个范围：

形式=偏移量（计数*2000）到=从999

Answer 2

如果我理解正确，您不希望预先获取1m记录，而是希望它以1000个为一批，然后以两个线程处理它们，但要使其并行。首先，必须在数据库查询中使用RowCount或其他方法实现分页类型特性。在Java中，您可以将fromRowCount传递到toRowCount，并在1000个批中获取记录，并在线程中并行处理它们。我在这里添加了示例代码，但您必须进一步实现不同变量的逻辑。

        int totalRecordCount = 100000;
        int batchSize =1000;
        ExecutorService executor = Executors.newFixedThreadPool(totalRecordCount/batchSize);
        for(int x=0; x < totalRecordCount;){
            int toRowCount = x+batchSize;
            partList=getKParts(10,x,toRowCount);
            x= toRowCount + 1;
            executor.submit(new Runnable<>() {
                @Override
                public void run() {
                    operateOnList(partList);
                }
            });
        }

希望这有帮助。如果需要进一步澄清，请告诉我

Answer 3

当然，你可以同步代码。

public class MyClass {

    private final HibernateFetcher hibernateFetcher = new HibernateFetcher();

    private class Worker implements Runnable {    
       public run() {    
         List partList = hibernateFetcher.fetchRecords();
         operateOnList(partList);    
       }
    }

    public void myBatchProcessor() {

      while(!hibernateFetcher.isFinished()) {
      // create *n* workers and go!

      }    
   }       
}

class HibernateFetcher {        

  private int count = 0; 
  private final Object lock = new Object();
  private volatile boolean isFinished = false;  
  public List fetchRecords() {

      Criteria criteria = ...;

      synchronized(lock) {
         criteria.setFirstResult(count) // offset
                 .setMaxResults(1000);
         count=count+1000;
      }
      List result = criteria.list();
      isFinished = result.length > 0 ? false: true;
      return result;
  }

  public synchronized boolean isFinished(){
    return isFinished;
  }

}