Java多线程中的资源管理

假设：

有10项任务

有3个线程

有3个数组列表

与1个arrayList相关的每个线程

我的问题是：如何管理资源？例如，第一步3任务将使用3个线程和3个ArrayList执行。然后，每当一个线程可用时，第四个任务将与可用的arrayList一起执行。在Java中如何做到这一点？请给我参考或源代码

public class NewClass {

    private Queue<Integer> availableCore = new LinkedList();

    public void manage() throws InterruptedException {
        ArrayList<ArrayList<Integer>> data = new ArrayList<>();
        data.add(new ArrayList<>());
        data.add(new ArrayList<>());
        data.add(new ArrayList<>());

        availableCore.add(0);
        availableCore.add(1);
        availableCore.add(2);

        ArrayList<Calculate> allThreads = new ArrayList<>();
        ExecutorService es = Executors.newWorkStealingPool(3);
        int threadCount = -1;

        int numOfTask = 10;

        while (numOfTask > 0) {
            if (!availableCore.isEmpty()) {
                System.out.println(availableCore.element());
                threadCount++;
                int core = availableCore.remove();
                allThreads.add(new Calculate(data.get(core), numOfTask, core));
                es.execute(allThreads.get(threadCount));
                numOfTask--;
            }
        }

        es.shutdown();
        boolean finished = es.awaitTermination(1, TimeUnit.DAYS);
        System.out.println("Done\n");

        for (int i = 0; i < data.size(); i++) {
            System.out.println(data.get(i));
        }
    }

    public class Calculate extends Thread {

        private ArrayList<Integer> data;
        private int start;
        private int core;

        public Calculate(ArrayList<Integer> data, int start, int core) {
            this.data = data;
            this.start = start;
            this.core = core;
        }

        @Override
        public void run() {
            this.data.add(start);
            availableCore.add(this.core);
        }

        public int getCore() {
            return core;
        }
    }
}

我的问题是：如何管理资源？例如，第一步 将使用4个core和4个arrayList执行4个任务。然后每当 core可用，第5个任务将与可用任务一起执行 arrayList。在Java中如何做到这一点？请给我参考或来源 代码

从本质上讲，Java没有将给定线程显式映射到给定核心的特性（即线程关联）。您可以通过显式的系统调用（例如在Linux操作系统中使用命令）来完成。但这将需要你做大量的工作，并且可能会失去可移植性

您最好使用更高级的Java摘要（例如）来处理这些低级的细节。使用

ExecutorService

将任务发送到线程池，让池和最终操作系统线程调度程序处理线程/任务之间的映射

顺便说一句，即使使用Java线程池，也不能保证线程会很好地映射到单独的核心

其他语言，如C/C++可能为您提供库，允许您显式地将核心映射到线程，例如使用

---

根据您的评论：

如果我只将任务发送到线程池而不管理 arrayList，它将消耗大量内存。假设1有100个任务 那么它将需要100个数组列表。。我想减少内存 仅使用4个arrayList进行消耗，以便在执行任务时重用 完成

在我看来，您似乎想要实现。一个线程将负责向队列添加工作（即，

ArrayList

s），其他线程将从队列请求工作并使用它

我的问题是：如何管理资源？例如，第一步 将使用4个core和4个arrayList执行4个任务。然后每当 core可用，第5个任务将与可用任务一起执行 arrayList。在Java中如何做到这一点？请给我参考或来源 代码

从本质上讲，Java没有将给定线程显式映射到给定核心的特性（即线程关联）。您可以通过显式的系统调用（例如在Linux操作系统中使用命令）来完成。但这将需要你做大量的工作，并且可能会失去可移植性

您最好使用更高级的Java摘要（例如）来处理这些低级的细节。使用

ExecutorService

将任务发送到线程池，让池和最终操作系统线程调度程序处理线程/任务之间的映射

顺便说一句，即使使用Java线程池，也不能保证线程会很好地映射到单独的核心

其他语言，如C/C++可能为您提供库，允许您显式地将核心映射到线程，例如使用

---

根据您的评论：

如果我只将任务发送到线程池而不管理 arrayList，它将消耗大量内存。假设1有100个任务 那么它将需要100个数组列表。。我想减少内存 仅使用4个arrayList进行消耗，以便在执行任务时重用 完成

在我看来，您似乎想要实现。一个线程将负责向队列添加工作（即，

ArrayList

s），其他线程将从队列请求工作并使用它。

如前所述，我们无法将线程映射到核心。但是，您可以使用

ExecutorService

执行任务。在本例中，每个任务使用线程，代码如下所示：

import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Cores {

    private static ExecutorService service = Executors.newFixedThreadPool(4);

    public static void main(String[] args) {
        List<String> first = List.of("1", "2", "3");
        List<String> second = List.of("1", "2", "3");
        List<String> third = List.of("1", "2", "3");
        List<String> fourth = List.of("1", "2", "3");
        List<String> fifth = List.of("1", "2", "3");

        sendToExecutor(first, second, third, fourth, fifth);

        service.shutdown();
    }

    @SafeVarargs
    public static void sendToExecutor(List<String>... lists) {
        for (List<String> list : lists) {
            service.execute(() -> handleWholeList(list));
        }
    }

    public static void handleWholeList(List<String> strings) {
        strings.forEach(s -> System.out.printf("String %s handled in thread %s%n", s, Thread.currentThread().getName()));
    }
}

您可以使用可用处理器的数量：

private static ExecutorService service = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

如前所述，我们无法将线程映射到核心。但是，您可以使用

ExecutorService

执行任务。在本例中，每个任务使用线程，代码如下所示：

import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Cores {

    private static ExecutorService service = Executors.newFixedThreadPool(4);

    public static void main(String[] args) {
        List<String> first = List.of("1", "2", "3");
        List<String> second = List.of("1", "2", "3");
        List<String> third = List.of("1", "2", "3");
        List<String> fourth = List.of("1", "2", "3");
        List<String> fifth = List.of("1", "2", "3");

        sendToExecutor(first, second, third, fourth, fifth);

        service.shutdown();
    }

    @SafeVarargs
    public static void sendToExecutor(List<String>... lists) {
        for (List<String> list : lists) {
            service.execute(() -> handleWholeList(list));
        }
    }

    public static void handleWholeList(List<String> strings) {
        strings.forEach(s -> System.out.printf("String %s handled in thread %s%n", s, Thread.currentThread().getName()));
    }
}

您可以使用可用处理器的数量：

private static ExecutorService service = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

---

它是生产者和消费者的工作模式。非常感谢@dreamcrash。这是一个有效的生产者和消费者模式。非常感谢@dreamcrash。