java 多线程分片处理list

原创

mob64ca12f8da8d 2024-10-02 05:39:01 ©著作权

©著作权归作者所有：来自51CTO博客作者mob64ca12f8da8d的原创作品，请联系作者获取转载授权，否则将追究法律责任

Java 多线程分片处理 List

在现代软件开发中，多线程是一项不可或缺的技术，用于提升应用程序的性能和响应能力。尤其是在处理大的数据集合时，分片处理可以显著提高程序的执行效率。本文将全面介绍如何在 Java 中实现多线程分片处理 List。

整体流程

我们将通过以下几个步骤实现多线程分片处理 List：

步骤	描述
1	定义数据和分片的逻辑
2	创建线程类
3	实现任务接口
4	启动线程并执行分片处理
5	等待所有线程完成并整合结果

接下来，我们将详细介绍每一步需要实现的代码。

1. 定义数据和分片的逻辑

首先，我们需要准备一个 List 数据，并定义如何将这个 List 分成若干个子 List。

import java.util.ArrayList;
import java.util.List;

public class ListSplitter {

    // 方法：将列表按指定的大小分片
    public static List<List<Integer>> splitList(List<Integer> list, int chunkSize) {
        List<List<Integer>> chunks = new ArrayList<>();
        for (int i = 0; i < list.size(); i += chunkSize) {
            chunks.add(new ArrayList<>(list.subList(i, Math.min(i + chunkSize, list.size()))));
        }
        return chunks;
    }
}

这里，我们定义了一个 splitList 方法，该方法将输入的 List 按照指定的每个块的大小分片。

2. 创建线程类

我们将创建一个线程类用于处理每个数据块。

public class WorkerThread extends Thread {
    private List<Integer> data;

    // 构造函数：接收一个待处理的子 List
    public WorkerThread(List<Integer> data) {
        this.data = data;
    }

    @Override
    public void run() {
        // 处理数据
        for (Integer number : data) {
            System.out.println("Processing: " + number);
            // 在这里可以添加更多具体的处理逻辑
        }
    }
}

WorkerThread 类继承自 Thread 类，接受一个 List 数据来进行处理。run 方法中执行具体的处理逻辑。

3. 实现任务接口

接下来，我们需要定义一个接口，方便我们后期的扩展。

public interface Task {
    void execute(List<Integer> data);
}

这个接口定义了一个 execute 方法，用于处理 List 中的数据，便于后期添加其他实现。

4. 启动线程并执行分片处理

在这一步中，我们将利用前面定义的 ListSplitter 和 WorkerThread 启动多个线程。

import java.util.List;

public class Main {
    public static void main(String[] args) {
        // 定义一个大的数据 List
        List<Integer> data = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        int chunkSize = 3;

        // 将数据分成多个块
        List<List<Integer>> chunks = ListSplitter.splitList(data, chunkSize);
        
        // 创建并启动线程
        for (List<Integer> chunk : chunks) {
            WorkerThread thread = new WorkerThread(chunk);
            thread.start();
        }
    }
}

在 main 方法中，我们首先定义了一个大的数据 List，然后使用 splitList 方法将其分片。接着，为每个分片创建一个 WorkerThread 实例并启动它们。

5. 等待所有线程完成并整合结果

在多线程环境中，我们常常需要等待所有线程完成工作，之后再进行后续操作。在这里，我们可以使用 join() 方法。

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        List<Integer> data = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        int chunkSize = 3;

        List<List<Integer>> chunks = ListSplitter.splitList(data, chunkSize);
        List<WorkerThread> threads = new ArrayList<>();
        
        for (List<Integer> chunk : chunks) {
            WorkerThread thread = new WorkerThread(chunk);
            thread.start();
            threads.add(thread);
        }

        // 等待所有线程完成
        for (WorkerThread thread : threads) {
            thread.join();
        }

        System.out.println("All threads have completed processing.");
    }
}

通过 join() 方法，我们可以确保主线程在所有工作线程完成后再继续执行后续逻辑。

类图

以下是整个系统的类图，标识了各个类之间的关系。

classDiagram
    class Main {
        +main(String[] args)
    }
    class ListSplitter {
        +splitList(List<Integer> list, int chunkSize)
    }
    class WorkerThread {
        -List<Integer> data
        +WorkerThread(List<Integer> data)
        +run()
    }
    Main --> ListSplitter
    Main --> WorkerThread