Задача, которую я пытаюсь реализовать, состоит в том, чтобы найти последовательность Коллатца для чисел в заданном интервале с использованием нескольких потоков и посмотреть, насколько улучшено улучшение по сравнению с одним потоком.
Однако один поток всегда быстрее, независимо от того, выбираю ли я 2 потока (редактировать. 2 потока быстрее, но ненамного, а 4 потока медленнее, чем 1 поток, и я понятия не имею, почему. (Я мог бы даже сказать, что чем больше потоков тем медленнее становится). Надеюсь, кто-нибудь объяснит. Может я что-то не так делаю.
Ниже приведен мой код, который я написал до сих пор. Я использую ThreadPoolExecutor для выполнения задач (одна задача = одна последовательность Коллатца для одного числа в интервале).
Класс Коллатца:
public class ParallelCollatz implements Runnable {
private long result;
private long inputNum;
public long getResult() {
return result;
}
public void setResult(long result) {
this.result = result;
}
public long getInputNum() {
return inputNum;
}
public void setInputNum(long inputNum) {
this.inputNum = inputNum;
}
public void run() {
//System.out.println("number:" + inputNum);
//System.out.println("Thread:" + Thread.currentThread().getId());
//int j=0;
//if(Thread.currentThread().getId()==11) {
// ++j;
// System.out.println(j);
//}
long result = 1;
//main recursive computation
while (inputNum > 1) {
if (inputNum % 2 == 0) {
inputNum = inputNum / 2;
} else {
inputNum = inputNum * 3 + 1;
}
++result;
}
// try {
//Thread.sleep(10);
//} catch (InterruptedException e) {
// TODO Auto-generated catch block
// e.printStackTrace();
//}
this.result=result;
return;
}
}
И основной класс, где я запускаю потоки (да, пока я создаю два списка с одинаковыми номерами, так как после запуска с одним потоком начальные значения теряются):
ThreadPoolExecutor executor = (ThreadPoolExecutor)Executors.newFixedThreadPool(1);
ThreadPoolExecutor executor2 = (ThreadPoolExecutor)Executors.newFixedThreadPool(4);
List<ParallelCollatz> tasks = new ArrayList<ParallelCollatz>();
for(int i=1; i<=1000000; i++) {
ParallelCollatz task = new ParallelCollatz();
task.setInputNum((long)(i+1000000));
tasks.add(task);
}
long startTime = System.nanoTime();
for(int i=0; i<1000000; i++) {
executor.execute(tasks.get(i));
}
executor.shutdown();
boolean tempFirst=false;
try {
tempFirst =executor.awaitTermination(5, TimeUnit.HOURS);
} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
System.out.println("tempFirst " + tempFirst);
long endTime = System.nanoTime();
long durationInNano = endTime - startTime;
long durationInMillis = TimeUnit.NANOSECONDS.toMillis(durationInNano); //Total execution time in nano seconds
System.out.println("laikas " +durationInMillis);
List<ParallelCollatz> tasks2 = new ArrayList<ParallelCollatz>();
for(int i=1; i<=1000000; i++) {
ParallelCollatz task = new ParallelCollatz();
task.setInputNum((long)(i+1000000));
tasks2.add(task);
}
long startTime2 = System.nanoTime();
for(int i=0; i<1000000; i++) {
executor2.execute(tasks2.get(i));
}
executor2.shutdown();
boolean temp =false;
try {
temp=executor2.awaitTermination(5, TimeUnit.HOURS);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("temp "+ temp);
long endTime2 = System.nanoTime();
long durationInNano2 = endTime2 - startTime2;
long durationInMillis2 = TimeUnit.NANOSECONDS.toMillis(durationInNano2); //Total execution time in nano seconds
System.out.println("laikas2 " +durationInMillis2);
Например, работа с одним потоком завершается за 3280 мс. Запуск с двумя потоками 3437 мс. Должен ли я рассматривать другую параллельную структуру для вычисления каждого элемента?
ИЗМЕНИТЬ Пояснение. Я не пытаюсь распараллелить отдельные последовательности, а интервал чисел, когда каждое число имеет свою последовательность (что не связано с другими числами).
ИЗМЕНИТЬ2
Сегодня я запустил программу на хорошем ПК с 6 ядрами и 12 логическими процессорами, и проблема осталась. Кто-нибудь знает, где может быть проблема? Я также обновил свой код. 4 потока по какой-то причине работают хуже, чем 2 потока (даже хуже, чем 1 поток). Я также применил то, что было дано в ответе, но без изменений.
Еще одно редактирование Я заметил, что если я добавляю Thread.sleep(1) в свой метод ParallelCollatz, производительность постепенно увеличивается с увеличением количества потоков. Возможно, эта деталь подскажет кому-то, что не так? Однако независимо от того, сколько задач я даю, если нет Thread.Sleep(1), 2 потока работают быстрее всего, 1 поток находится на 2-м месте, а другие зависают примерно на такое же количество миллисекунд, но медленнее, чем 1 и 2 потока.
Новое редактирование Я также пробовал помещать больше задач (для цикла для вычисления не 1, а 10 или 100 последовательностей Коллатца) в методе run() класса Runnable, чтобы сам поток выполнял больше работы. К сожалению, это тоже не помогло. Может я неправильно запускаю задачи? У кого-нибудь есть идеи?
EDIT Таким образом, может показаться, что после добавления дополнительных задач в метод запуска это немного исправляется, но для большего количества потоков проблема все еще остается 8+. Мне все еще интересно, причина этого в том, что для создания и запуска потоков требуется больше времени, чем для выполнения задачи? Или мне создать новый пост с этим вопросом?
