Question

我在java中自学多线程。我的假设示例是我有一个我想要排序的大型记录列表（一个2D数组）。单线程方法是使用循环遍历记录列表并进行排序。我想多线程我的程序用固定数字线程对我的列表进行排序，在这种情况下2.一个线程将对列表的前半部分进行排序，第二个线程将对剩余的一半进行排序。然后我想输出现在排序的记录列表的结果。

如何创建工作线程池并对记录列表进行排序？我是否需要担心data是共享资源？如何将每个线程的结果返回到原始记录列表？以下是我的代码。

import java.util.*;

class RunnableProcess implements Runnable {
  private int[] data;

  public RunnableProcess(int[] data) {
      this.data = data;
  }

  public void run() {
    try {

      // sort the records this thread has access to
      for (int i = 0; i < data.length; i++) {
        Arrays.sort(data[i]);
      }

    } catch(Exception ex) {
        ex.printStackTrace();
    }
  }
}

class BigData {

  static int[][] data = new int[1000][1000];

  public static void main(String [] args) {


    // Create records 
    for (int i = 0; i < data.length; i++) {
      for (int j = 0; j < data[0].length; j++) {
        data[i][j] = new Random().nextInt(999);
      }
    }

    // Call on two threads to sort the data variable
    // ExecutorService executor = Executors.newFixedThreadPool(2);


   // Python type of idea: Pass half the records to each thread and start
   // java doesn't support this so what is the java way of doing this?

   // Thread thread = new Thread(new RunnableProcess(data[:499]));
   // thread.start();

   // Thread thread = new Thread(new RunnableProcess(data[499:]));
   // thread.start();

  }
}

我对解决这个问题的最佳方法持开放态度。

Answer 1

Java不支持以与python相同的方式切割本机数组。我们可以使用ArrayList来接近。

首先，抛开一边。随机数据生成效率非常低。您正在为生成的每个随机数创建一个新的Random数字生成器对象。你只需要一个发电机，如下：

Random rnd = new Random();                     // Only created once
for (int i = 0; i < data.length; i++) {
    for (int j = 0; j < data[0].length; j++) {
        data[i][j] = rnd.nextInt(999);
    }
}

创建数据后，我们可以将此原生int[][] 2d数组转换为List条记录，其中每条记录都是int[] 1d数组：

List<int[]> records = Arrays.asList(data);

请注意，这不会复制数组中的值。它创建了一个List数组视图。对data中存储的值的任何更改都将反映在records中，反之亦然。

我们这样做，因此我们可以使用List#subList()方法将列表拆分为两个视图。

List<int[]> first_half = records.subList(0, 500);
List<int[]> second_half = records.subList(500, 1000);

同样，这些视图由原始列表支持（由原始数组支持）。通过视图所做的更改将反映在原始文件中。

由于我们现在将记录存储在List而不是数组中，因此我们需要更新RunnableProcess以使用此新格式：

class RunnableProcess implements Runnable {
    private List<int[]> records;

    public RunnableProcess(List<int[]> records) {
        this.records = records;
    }

    @Override
    public void run() {
        // sort the records this thread has access to
        for (int[] record : records) {
            Arrays.sort(record);
        }
    }
}

我们现在将数据划分为两个独立的集合，以及可以对每个集合进行操作的RunnableProcess。现在，我们可以开始多线程了。

ExecutorService executor = Executors.newFixedThreadPool(2);

此执行程序服务创建一个包含两个线程的池，并将一遍又一遍地重用这些线程，以用于提交给此执行程序的后续任务。因此， NOT 需要创建并启动自己的线程。遗嘱执行人将处理此事。

executor.submit(new RunnableProcess(first_half));
executor.submit(new RunnableProcess(second_half));

由于我们想知道这些任务何时完成，我们需要保存从Future返回的executor.submit()：

Future<?> task1 = executor.submit(new RunnableProcess(first_half));
Future<?> task2 = executor.submit(new RunnableProcess(second_half));

调用Future#get()等待任务完成，并检索任务的结果。（注意：由于我们的Runnable未返回值，因此将返回null值。）

task1.get();  // Wait for first task to finish ...
task2.get();  // ... as well as the second task to finish.

最后，您需要#shutdown()执行者，否则您的程序可能无法正常终止。

executor.shutdown();

完整示例：

List<int[]> records = Arrays.asList(data);
List<int[]> first_half = records.subList(0, 500);
List<int[]> second_half = records.subList(500, 1000);

ExecutorService executor = Executors.newFixedThreadPool(2);

try {
    Future<?> task1 = executor.submit(new RunnableProcess(first_half));
    Future<?> task2 = executor.submit(new RunnableProcess(second_half));

    task1.get();  // Wait for first task to finish ...
    task2.get();  // ... as well as the second task to finish.
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

executor.shutdown();

我是否需要担心数据是共享资源？

在这种情况下，没有。您的data是一个数组数组。每个线程仅引用data数组（作为List），以获取对int[]记录的引用。 data数组本身不会被修改;只有记录，但每个记录只由其中一个线程修改。

如何将每个线程的结果返回到原始记录列表？

由于记录正在“就地”排序，因此您的data变量已包含您的已排序记录数组。对Future#get()的调用可确保每个Thread已完成其处理，以便可以再次从主线程安全地访问数据。

如何在java中使用多线程对记录列表进行排序？

1 个答案: