如何创建用户定义的线程数？

Question

在我正在处理的程序中，我希望用户能够输入他们的处理器拥有的处理线程数，以便程序可以在线程数之间分配工作负载（它正在进行一般计算）用户的电脑有。

或者，有没有一种方法可以让程序检测系统配置以获取线程数而无需询问用户？这会更好，但我不知道是否有办法做到这一点。

这是我唯一能想到的。我知道这是完全不正确的，你不能这样命名一个线程，但我是一个初学者（还在上高中），我只是想包括一些东西来表明我正在尝试。

for(int i = 0; i < threads; i++) {

    Thread thread(i) = new Thread(){
        public void run() {
            double endNum = 0;

            for(double numberRun = 0; numberRun <= calcs/threads; numberRun++){
                endNum += (num * 999999999);
            }

            System.out.println("Thread " + i + " complete! The numerical result of the calculation is " + endNum);
        }
    };
}

每个不确定我在说什么的人，我正在尝试创建计算机拥有的线程数，也就是内核数，或者，如果它使用的是英特尔的超线程，那么内核数是两倍。您可以拥有比系统一次能够执行的线程更多的线程，但我正在尝试做最有效的事情，并将计算总数划分为系统能够同时执行的线程数。我不知道如何让用户定义线程数然后创建该线程数（或者让程序确定系统拥有的线程数然后创建该数）。

Answer 1

您可以像这样了解 JVM 有多少个处理器可用：

Runtime.getRuntime().availableProcessors()

用于拆分纯数值计算的最佳线程数可能是每个处理器一个。如果这些线程中的任何一个不得不偶尔阻塞 IO，那可能会更多。

Answer 2

class Task implements Runnable {
  Task(/** Whatever you need to identify the subset of tasks to run goes here*/) {

  }

  public void run() {
    // do the calcs
  }
}

int nProcs = Runtime.getRuntime().getAvailableProcessors();

Task[] tasks = new Task[nProcs];
for (int i = 0; i < nProcs; i++) {
   tasks[i] = new Task(/** Whatever parameters for this batch*/);
   new Thread(tasks[i]).start(); 
   // Alternatively, use Executors.newFixedThreadPool() to get a service above, and submit the runnable there, getting a future for the result, something like this:
   Future f = executor.submit(task[i]);
}

}

Answer 3

如果您要执行一堆不同的不同任务，而不是尝试将一个大任务拆分为多个并行运行的小任务，您可能需要使用Executor：

Executor e = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
// run a single task
e.execute(new Runnable() {
    public void run() {
        // do stuff here
    }
});

正如其他人指出的那样，线程池的最佳大小取决于各种因素，例如任务执行的 IO 量，但可用内核的数量应该是一个合理的默认值。

Answer 4

我喜欢使用的是 ExecutorService executor = Executors.newFixedSizeThreadPool(int numberOfThreads);

然后让 executor.execute(myRunnable) 你的 runnables :) 在这种方法中，您不负责创建线程，并且您可以保证不会创建不必要的线程。

但至于如何确定应该使用多少线程，则由您自己研究。

Answer 5

在我看来，您正在寻找的也是任务到线程的映射策略。比如这样的循环：

for(int i = 0; i < LARGE_NUMBER; i++) {
    f(i);
}

可以转换为并行版本：

class Task implements Runnable {
    private int i;

    public Task(int i) {
       this.i = i;
    }       

    public void run() {
       f(i);
    }
}

然后将最初的 for 循环替换为：

ExecutorService exec = Executors.newCachedThreadPool();
for(int i = 0; i < LARGE_NUMBER; i++) {
    exec.submit(new Task(i));
}

exec.awaitTermination(1000, TimeUnit.HOURS); // wait for all tasks to finish

ExecutorService 将负责使用与可用处理器相关的足够线程数，并回收线程以便按需执行任务。

Answer 6

线程数不取决于处理器。如果您使用的是单处理器，那么您的程序将从一个线程跳转到另一个线程。

所以，你的方法没有任何“不正确”的地方（当然，如果你能正确使用它的话）。

Answer 7

我想您是在问系统可以拥有的最大线程数？？

正如here 所讨论的，系统可以拥有的线程数没有最大限制（因为Java 程序在Java 虚拟机中运行，您将拥有的限制是Java 虚拟机- JVM 的限制）。限制是您可以分配给线程的资源量。

如果您询问当前正在运行多少线程（可能已由任何外部程序或 JVM 内部启动），那么您可能会发现，但我认为它没有任何用处对于您的情况，因为您启动的线程与系统中运行的其他线程没有任何关系！