Как создать определенное пользователем количество потоков?

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); 
     } 
    }; 
} 

Все, кто не уверен, что я говорю, я пытаюсь создать несколько потоков, что компьютер, иначе количество ядер, или, если он использует Intel, HyperThreading, в два раза количество ядер. У вас может быть больше потоков, чем система может выполнять сразу, но я пытаюсь сделать самую эффективную вещь и делить общее количество вычислений на количество потоков, которые система может выполнять одновременно. Я не знаю, как дать пользователю определить количество потоков, а затем создать это число потоков (или позволить программе определить количество потоков, которые система имеет, а затем создать это число).

Answer 1

Количество потоков не зависит от процессора. Если вы используете один процессор, ваша программа будет переходить из одного потока в другой.

Итак, в вашем методе нет ничего «неправильного» (конечно, если вы будете использовать его правильно).

Answer 2

Я думаю, вы спрашиваете о МАКСИМАЛЬНОМ числе потоков, которые может иметь система?

Как обсуждалось here, нет максимального количества потоков, которые может иметь система (так как Java-программы запускаются внутри виртуальной машины Java, ограничение, которое у вас будет, - это виртуальная машина Java JVM). Ограничение на количество ресурсов, которые вы можете выделить на свои потоки.

Если вы спрашиваете, сколько потоков в данный момент выполняется (возможно, это было запущено какой-либо внешней программой или внутри JVM), вы, вероятно, можете это узнать, но я думаю, что это не будет используйте для своего случая, поскольку нитки, которые вы запускаете, никак не связаны с другими потоками, запущенными в системе!

Answer 3

то, что мне нравится использовать, является Исполнитель-исполнитель = Executors.newFixedSizeThreadPool (int numberOfThreads);

, а затем у вас есть executor.execute (myRunnable) ваши runnables :) В этом подходе вы несете ответственность за создание потоков, и у вас есть гарантия, что вы не создаете ненужные потоки.

, но как вы могли бы выяснить, сколько потоков вы должны использовать, это зависит от вас, чтобы исследовать.

Answer 4

Вы можете узнать, сколько процессоры доступны для JVM, как это:

Runtime.getRuntime().availableProcessors() 

Оптимальное число нитей для расщепления чисто числовой расчет более вероятно один на один процессор.Если какой-либо из этих потоков приходится время от времени блокировать IO, это может быть больше.

Answer 5

Если вы собираетесь выполнение кучу различных различных задач - в противоположность попытке разделить одну большую задачу на несколько более мелких задач, работающих параллельно, вы можете захотеть использовать Executor:

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

Как указывали другие, оптимальный размер пула потоков зависит от различных факторов, таких как количество операций ввода-вывода, но количество доступных ядер должно быть разумным по умолчанию.

Answer 6

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 7

Мне кажется, что то, что вы ищете также отображение стратегия задач в нитки. Например, цикл, такие как:

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); 
    } 
} 

затем заменить исходный для петли с:

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 примет заботиться о том, чтобы использовать несколько потоков, соответствующих имеющимся процессорам, а также перерабатывать потоки таким образом, чтобы задачи выполнялись по требованию.