как сделать многопроцессорную обработку в java, и на какую скорость рассчитывать?

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

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

Это хорошее чтение: закон Амдаля

Закон Амдаля

Выигрыш определяется тем, сколько времени требуется для отображения / уменьшения данных.

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

Тогда данные должны быть объединены / агрегированы-не зная больше, невозможно угадать. Если вся обработка зависит от наличия всех данных, это более высокий хит, чем если бы конечная результаты могут быть рассчитаны независимо.

У вас есть очень небольшое количество очень маленьких файлов: если то, что вы делаете, не является вычислительно дорогим, я сомневаюсь, что это стоило бы усилий, но трудно сказать. Предполагая отсутствие узких мест сети / диска, вы получите (Очень) примерно линейное ускорение с дельтой для агрегирования результатов. Истинное ускорение / Дельта зависит от множества факторов, о которых мы на данный момент мало что знаем.

OTOH, вы можете настроить небольшую настройку Hadoop и просто попробуйте и посмотрите, что получится.

Проверьте документы на вашем JVM, чтобы увидеть, поддерживает ли он многопоточность. Я почти уверен, что солнечные тоже. параллелизм Java на практике является отправной точкой для многопоточности.

Первая часть вашего вопроса: Является ли многопроцессорная обработка более эффективной, чем многопоточность, с точки зрения производительности? В системе с надежной поддержкой многопоточности потоки всегда должны превосходить процессы с точки зрения производительности. Существует больше изоляции между потоками (нет общего доступа память, если явно не настроена с помощью механизма IPC), поэтому вы можете пойти по многопроцессному маршруту, чтобы опасные потоки не наступали друг на друга.

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

Что касается того, почему упоминаются многопроцессорные приложения , я думаю, что автор хочет быть полным. Хотя учебник не предоставляется, ссылка на дополнительную документацию есть. Большим недостатком использования многопроцессорной обработки является то, что вам приходится иметь дело с межпроцессным взаимодействием. В отличие от потоков, вы не можете просто поделиться какой-то памятью и бросить вокруг нее несколько мьютексов и назвать это днем.

---

Из комментариев следует, что существует некоторая путаница относительно того, что такое" многопроцессорная обработка " на самом деле. Потоки-это конструкции, которые должны быть созданы вашим кодом. Существуют API для создания потоков и управление. Процессы, однако, могут быть созданы вручную в командной строке. На коробке unix выполните следующие действия, чтобы запустить четыре экземпляра (процесса) foo. Обратите внимание, что требуется окончательный &.

$ ./foo & ./foo & ./foo & ./foo &

Теперь, если у вас есть входной файл bar, который нужно обработать foo, используйте что-то вроде split, чтобы разбить его на четыре равных сегмента и запустить foo на нем:

$ ./foo bar.0 > bar.0.out & ./foo bar.1 > bar.1.out & ./foo bar.2 > bar.2.out & ./foo bar.3 > bar.3.out &

Наконец, вам нужно будет объединить файлы bar.?.out. Запуск теста, подобного этому, должен дать вам некоторое представление о том, используете ли вы тяжелые процессы-хорошая идея для вашего приложения. Если вы уже создали многопоточное приложение, это, вероятно, будет просто замечательно. Но не стесняйтесь проводить некоторые эксперименты, чтобы увидеть, работают ли процессы лучше. Как только вы убедитесь, что процессы-это правильный путь, реорганизуйте свой код, чтобы использовать ProcessBuilder для запуска процессов самостоятельно.

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

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

В целом, при выборе решения для параллельного программирования следует провести некоторый анализ, поскольку наиболее эффективное решение может варьироваться в зависимости от конкретного случая. Многопоточность не может считаться более эффективной, чем многопроцессорная обработка, поскольку существуют парадоксальные ситуации, когда многопоточность работает хуже, чем один поток. Когда производительность является основным кроме того, запустите бенчмарки для сравнения решений single thread single process vs multithreading vs multiprocessing, чтобы убедиться, что вы действительно получаете ожидаемые преимущества производительности.

Вкратце отметим, что при выборе решения помимо производительности существуют и другие соображения.

Существует несколько способов запуска нового процесса в Java:

1. ProcessBuilder.start()
2. Runtime.exec() работает вокруг ProcessBuilder
3. Apache Commons Exec, который работает вокруг Runtime.exec()

С ProcessBuilder:

ProcessBuilder pb =
new ProcessBuilder("myCommand", "myArg1", "myArg2");
Map<String, String> env = pb.environment();
env.put("VAR1", "myValue");
env.remove("OTHERVAR");
env.put("VAR2", env.get("VAR1") + "suffix");
pb.directory(new File("myDir"));
File log = new File("log");
pb.redirectErrorStream(true);
pb.redirectOutput(Redirect.appendTo(log));
Process p = pb.start();
assert pb.redirectInput() == Redirect.PIPE;
assert pb.redirectOutput().file() == log;
assert p.getInputStream().read() == -1;

С Runtime:

Runtime r = Runtime.getRuntime();
Process p = r.exec("firefox");
p.waitFor(10, TimeUnit.SECONDS);
p.destroy();

С Apache Commons Exec:

String line = "AcroRd32.exe /p /h " + file.getAbsolutePath();
CommandLine cmdLine = CommandLine.parse(line);
DefaultExecutor executor = new DefaultExecutor();
int exitValue = executor.execute(cmdLine);

Ключевые отличия многопроцессорной обработки и многопоточности от этой :

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

Дополнительные ссылки:

• https://alvinalexander.com/java/java-exec-processbuilder-process-1
• https://alvinalexander.com/java/java-exec-processbuilder-process-2
• https://alvinalexander.com/java/java-exec-processbuilder-process-3