В чем разница между параллельным программированием и параллельным программированием? Я спросил у Google, но не нашел ничего, что помогло мне понять эту разницу. Не могли бы вы привести мне пример для обоих?
В настоящее время я нашел это объяснение: http://www.linux-mag.com/id/7411 - но "concurrency является свойством программы" против "параллельного выполнения свойство машины" для меня мало, но я не могу сказать, что к чему.
Если ваша программа использует потоки (параллельное программирование), она не обязательно будет выполняться как таковая (параллельное выполнение), поскольку это зависит от того, может ли машина обрабатывать несколько потоков.
Вот наглядный пример. Резьбы на не резьбовом станке:
-- -- --
/ \
>---- -- -- -- -- ---->>
Резьбы на резьбовом станке:
------
/ \
>-------------->>
Тире представляют выполненный код. Как вы можете видеть, они оба разделяются и выполняются по отдельности, но многопоточная машина может выполнять несколько отдельных частей одновременно.
Параллельное программирование относится к операциям, которые кажутся перекрывающимися, и в первую очередь касается сложности, возникающей из-за недетерминированного потока управления. Количественные затраты, связанные с параллельными программами, обычно являются как пропускной способностью, так и задержкой. Параллельные программы часто связаны с вводом-выводом, но не всегда, например одновременные сборщики мусора полностью на процессоре. Педагогическим примером параллельной программы является веб-сканер. Эта программа инициирует запросы на веб-страницы и принимает ответы одновременно, когда результаты загрузок становятся доступными, накапливая набор страниц, которые уже были посещены. Поток управления является недетерминированным, поскольку ответы не обязательно принимаются в одном и том же порядке при каждом запуске программы. Эта характеристика может сильно затруднить отладку параллельных программ. Некоторые приложения принципиально параллельны, например, веб-серверы должны обрабатывать клиентские подключения одновременно. Erlang, F # асинхронные рабочие процессы и библиотека Scala Akka, возможно, являются наиболее перспективными подходами к высококонкурентному программированию.
Многоядерное программирование является частным случаем параллельного программирования. Параллельное программирование касается операций, которые перекрываются для конкретной цели повышения пропускной способности. Сложности параллельного программирования можно избежать, сделав поток управления детерминированным. Как правило, программы порождают наборы дочерних задач, которые выполняются параллельно, а родительская задача продолжается только после завершения каждой подзадачи. Это делает параллельные программы намного проще для отладки, чем параллельные программы. Сложной частью параллельного программирования является оптимизация производительности по таким вопросам, как гранулярность и коммуникация. Последнее по-прежнему является проблемой в контексте многоядерных процессоров, поскольку перенос данных из одного кэша в другой сопряжен со значительными затратами. Плотное матрично-матричное умножение является педагогическим примером параллельного программирования и может быть эффективно решено с помощью алгоритма Straasen "разделяй и властвуй" и параллельной атаки на подзадачи. Cilk - это, пожалуй, самый многообещающий подход для высокопроизводительного параллельного программирования на многоядерных процессорах, который был применен как в многопоточных строительных блоках Intel, так и в параллельной библиотеке задач Microsoft ( в .NET 4).
https://joearms.github.io/published/2013-04-05-concurrent-and-parallel-programming.html
Concurrent = две очереди и одна кофемашина.
Параллель = две очереди и две кофейные машины.
Интерпретация исходного вопроса как параллельного/параллельного вычисления вместо программирования.
В параллельном вычислении два вычисления продвигают независимо друг от друга. Второе вычисление не нужно ждать, пока первый закончен, чтобы он продвигался вперед. Однако в нем не указано, каким образом это достигается. В одноядерной настройке требуется приостановка и чередование потоков (также называемая упреждающей многопотоковой обработкой).
В параллельном вычислении два вычисления одновременно продвигаются - это буквально в одно и то же время. Это невозможно при использовании одного процессора и требует многоядерной настройки.
по сравнению с
В соответствии с: "Параллельный против Concurrent в Node.js" .
По мнению процессора, это можно описать с помощью этой картинки
По мнению процессора, это можно описать с помощью этой картинки
Я считаю, что параллельное программирование относится к многопоточному программированию, которое позволяет запустить вашу программу несколькими потоками, абстрагироваться от деталей оборудования.
Параллельное программирование относится к конкретному проектированию ваших программных алгоритмов, чтобы воспользоваться преимуществами параллельного выполнения. Например, вы можете выполнить параллельно две ветки некоторых алгоритмов в ожидании того, что она ударит результат раньше (в среднем), чем если бы вы сначала проверили первую, а затем вторую ветвь.
Я нашел этот контент в каком-то блоге. Думал, что это полезно и актуально.
Concurrency и parallelism НЕ ТОЛЬКО. Две задачи T1 и T2 являются параллельными, если порядок выполнения двух задач во времени не задан,
T1 может быть выполнен и закончен до T2, T2 может быть выполнен и закончен до T1, T1 и T2 могут выполняться одновременно в одном и том же экземпляре времени (parallelism), T1 и T2 могут быть выполнены альтернативно, ... Если для одновременной работы двух параллельных потоков ОС на одном одноядерном процессоре без CMP без SMT, вы можете получить concurrency, но не parallelism. parallelism возможен на многоядерных, многопроцессорных или распределенных системах.
Concurrency часто упоминается как свойство программы и представляет собой понятие более общее, чем parallelism.
Источник: https://blogs.oracle.com/yuanlin/entry/concurrency_vs_parallelism_concurrent_programming
Это две фразы, которые описывают одно и то же (несколько) разные точки зрения. Параллельное программирование описывает ситуацию с точки зрения аппаратного обеспечения - по меньшей мере два процессора (возможно, в рамках одного физического пакета) работают параллельно с проблемой. Параллельное программирование описывает вещи более с точки зрения программного обеспечения - два или более действия могут происходить точно в одно и то же время (одновременно).
Проблема заключается в том, что люди пытаются использовать две фразы, чтобы провести четкое различие, когда их не существует. Реальность такова, что разделительная линия, которую они пытаются нарисовать, была нечеткой и нечеткой на протяжении десятилетий и со временем становилась все более нечеткой.
То, что они пытаются обсудить, это тот факт, что когда-то на большинстве компьютеров был только один процессор. Когда вы выполняли несколько процессов (или потоков) на одном процессоре, CPU выполнял только одну команду из одного из этих потоков за раз. Внешний вид concurrency был иллюзией: CPU переключается между выполнением инструкций из разных потоков достаточно быстро, что для восприятия человека (к которому все менее 100 мс выглядит мгновенно), похоже, что он делал много вещей одновременно.
Очевидный контраст с этим - компьютер с несколькими процессорами или процессор с несколькими ядрами, поэтому машина выполняет команды из нескольких потоков и/или процессов в одно и то же время; исполняемый код не может/не влияет на выполнение кода в другом.
Теперь проблема: такого чистого различия почти никогда не существовало. Разработчики компьютеров на самом деле довольно интеллектуальны, поэтому они давно заметили, что (например), когда вам нужно было читать некоторые данные с устройства ввода-вывода, такого как диск, потребовалось много времени (с точки зрения циклов процессора) до Конец. Вместо того, чтобы оставлять CPU бездействующим во время этого процесса, они выяснили различные способы разрешения одного процесса/потока выполнить запрос ввода-вывода и позволить коду из какого-либо другого процесса/потока выполнить на CPU, когда запрос ввода-вывода завершен.
Итак, задолго до того, как многоядерные процессоры стали нормой, у нас были операции из нескольких потоков, происходящих параллельно.
Это только верхушка айсберга. Десятилетия назад компьютеры начали предоставлять еще один уровень parallelism. Опять же, будучи достаточно умными людьми, разработчики компьютеров заметили, что во многих случаях у них были инструкции, которые не влияли друг на друга, поэтому одновременно можно было выполнить более одной инструкции из одного потока. Одним из ранних примеров, которые стали достаточно хорошо известны, были контрольные данные 6600. Это был (с довольно большой разницей) самый быстрый компьютер на земле, когда он был представлен в 1964 году, и большая часть той же базовой архитектуры остается в употреблении сегодня. Он отслеживал ресурсы, используемые каждой инструкцией, и имел набор исполнительных блоков, которые выполняли инструкции, как только ресурсы, на которых они зависели, стали доступными, очень похожи на дизайн самых последних процессоров Intel/AMD.
Но (как говорили рекламу) ждать - это не все. Там еще один элемент дизайна, который добавляет еще больше путаницы. Было дано довольно много разных имен (например, "Hyperthreading", "SMT", "CMP" ), но все они относятся к одной и той же базовой идее: процессор, который может выполнять несколько потоков одновременно, используя комбинацию некоторых ресурсов, которые независимы для каждого потока и некоторых ресурсов, которые совместно используются потоками. В типичном случае это сочетается с описанным выше уровнем уровня parallelism. Для этого у нас есть два (или более) набора архитектурных регистров. Затем мы имеем набор исполнительных блоков, которые могут выполнять инструкции, как только будут доступны необходимые ресурсы. Они часто хорошо сочетаются, потому что инструкции из отдельных потоков практически никогда не зависят от одних и тех же ресурсов.
Тогда, конечно, мы переходим к современным системам с несколькими ядрами. Здесь все очевидно, не так ли? У нас есть N (где-то между 2 и 256 или около того на данный момент) отдельные ядра, которые могут одновременно выполнять инструкции, поэтому у нас есть четкий случай реального parallelism - выполнение инструкций в одном процессе/потоке не влияет на выполнение инструкций в другом.
Ну, вроде. Даже здесь у нас есть некоторые независимые ресурсы (регистры, исполнительные блоки, по крайней мере один уровень кеша) и некоторые общие ресурсы (как правило, как минимум самый низкий уровень кеша, и, безусловно, контроллеры памяти и пропускная способность для памяти).
Подводя итог: простые сценарии, которые люди любят противопоставлять совместным ресурсам и независимым ресурсам, практически никогда не бывают в реальной жизни. Со всеми доступными ресурсами мы получаем нечто вроде MS-DOS, где мы можем запускать только одну программу за раз, и мы должны остановить ее, прежде чем мы сможем запустить другую. С полностью независимыми ресурсами у нас есть N компьютеров, на которых запущена MS-DOS (даже без сети для их подключения), не имея возможности совместно использовать что-либо между ними (потому что, если мы можем даже поделиться файлом, ну, что общий ресурс, нарушение основной предпосылки о том, что ничто не разделяется).
Каждый интересный случай включает некоторую комбинацию независимых ресурсов и общих ресурсов. Каждый разумно современный компьютер (и многие из которых совсем не современные) имеет как минимум некоторую способность выполнять хотя бы несколько независимых операций одновременно, и почти что-то более сложное, чем MS-DOS, воспользовалось этим, по крайней мере, в некоторой степени.
Хорошее, чистое разделение между "параллельными" и "параллельными", которые люди любят рисовать, просто не существует и почти никогда не имеет. То, что люди любят классифицировать как "параллельные", как правило, по-прежнему включает в себя по крайней мере один и часто более разные типы параллельного выполнения. То, что они любят классифицировать как "параллельные", часто связано с совместным использованием ресурсов и (например) одним процессом, блокирующим другое выполнение, при использовании ресурса, который был разделен между ними.
Люди, пытающиеся провести чистое различие между "параллельными" и "параллельными", живут в фантазии компьютеров, которые никогда не существовали.
Классическое планирование задач может быть последовательным, параллельным или параллельным.
Последовательный: задачи должны выполняться одна за другой в известном обманном порядке, иначе они не будут работать. Достаточно просто.
Параллельно: задачи должны выполняться одновременно, иначе это не сработает.
Старайтесь избегать этого, иначе к чаю у нас будут слезы.
Одновременно: нам все равно. Мы не небрежны, хотя: мы проанализировали это, и это не имеет значения; Поэтому мы можем выполнить любую задачу, используя любое доступное средство в любое время. Счастливые дни.
Часто доступное расписание изменяется при известных событиях, которые мы называем изменением состояния.
Люди часто думают, что речь идет о программном обеспечении, но на самом деле это концепция проектирования систем, которая предшествует компьютерам; программные системы были немного медленными в освоении, очень немногие языки программного обеспечения даже пытаются решить проблему. Вы можете попробовать поискать языковой барьер, если вам это интересно.
Вкратце, проектирование систем направлено на следующее:
Удачи.
В программировании параллелизм - это композиция независимо выполняющихся процессов, а параллелизм - одновременное выполнение (возможно, связанных) вычислений.
- Эндрю Герранд -
А также
Параллельность - это композиция независимо выполняемых вычислений. Параллелизм - это способ структурирования программного обеспечения, особенно как способ написания чистого кода, который хорошо взаимодействует с реальным миром. Это не параллелизм.
Параллелизм не параллелизм, хотя он допускает параллелизм. Если у вас только один процессор, ваша программа все еще может быть параллельной, но не может быть параллельной. С другой стороны, хорошо написанная параллельная программа может эффективно работать параллельно на многопроцессорной системе. Это свойство может быть важным...
- Роб Пайк -
Чтобы понять разницу, я настоятельно рекомендую посмотреть это видео Роба Пайка (одного из создателей Голанга). Параллелизм - это не параллелизм
Параллельное программирование происходит, когда код выполняется одновременно и каждое выполнение не зависит от другого. Следовательно, обычно нет озабоченности общими переменными, потому что это вряд ли произойдет.
Однако параллельное программирование состоит в том, что код выполняется разными процессами/потоками, которые совместно используют переменные и тому подобное, поэтому при параллельном программировании мы должны установить какое-то правило, чтобы решить, какой процесс/поток выполняется первым, мы хотим, чтобы мы были уверены в этом. будет последовательность и что мы можем точно знать, что произойдет. Если нет никакого контроля, и все потоки вычисляются в одно и то же время и хранят вещи в одних и тех же переменных, как мы узнаем, чего ожидать в итоге? Возможно, поток работает быстрее, чем другой, может быть, один из потоков даже остановился в середине своего выполнения, а другой продолжил другое вычисление с поврежденной (еще не полностью вычисленной) переменной, возможности безграничны. Именно в таких ситуациях мы обычно используем параллельное программирование вместо параллельного.
Concurrent programmingв общем смысле относится к средам, в которых определяемые нами задачи могут выполняться в любом порядке. Одна задача может возникать до или после другой, и некоторые или все задачи могут выполняться одновременно.
Parallel programmingспециально относится к одновременному выполнению параллельных задач на разных процессорах. Таким образом, все параллельное программирование является параллельным, но не все параллельное программирование является параллельным.
Я понял, какая разница:
1) Параллельно - работает в тандеме с использованием общих ресурсов 2) Параллельно - бок о бок с использованием разных ресурсов
Таким образом, вы можете иметь две вещи, происходящие в то же время независимо друг от друга, даже если они объединяются в точках (2) или двух вещах, опирающихся на одни и те же резервы во время выполняемых операций (1).
Хотя нет завершенного соглашение о различии между терминами, параллельными и параллельными, многие авторы делают следующие различия:
Таким образом, параллельные программы являются параллельными, но такая программа, как многозадачная операционная система, также является параллельной, даже когда она запускается на машине с только одно ядро, поскольку в любой момент могут выполняться несколько задач.
Источник: введение в параллельное программирование, Питер Пачеко
Concurrency является свойством программы, а параллельное выполнение является свойством машины. Какие параллельные части должны и не должны выполняться параллельно, можно ответить только тогда, когда известно точное оборудование. Что я хотел бы добавить, приводит к самому несчастливому выводу при работе с явным параллельным программированием. Нет гарантии как эффективности, так и переносимости с явными параллельными программами.
Параллелизм и параллелизм Источник
В многопоточном процессе на одном процессоре процессор может переключать ресурсы выполнения между потоками, что приводит к одновременному выполнению.
В одном и том же многопоточном процессе в многопроцессорной среде с общей памятью каждый поток в процессе может одновременно выполняться на отдельном процессоре, что приводит к параллельному выполнению.
Если в процессе меньше или столько потоков, сколько имеется процессоров, система поддержки потоков в сочетании с операционной средой гарантирует, что каждый поток будет работать на своем процессоре.
Например, в матричном умножении с одинаковым количеством потоков и процессоров каждый поток (и каждый процессор) вычисляет строку результата.
Разные люди говорят о разных видах параллелизма и параллелизма во многих конкретных случаях, поэтому необходимы некоторые абстракции, чтобы охватить их общую природу.
Основная абстракция делается в информатике, где и параллелизм, и параллелизм относятся к свойствам программ. Здесь программы представляют собой формализованные описания вычислений. Такие программы не должны быть на каком-либо конкретном языке или кодировке, которая зависит от реализации. Существование API/ABI/ISA/OS не имеет отношения к такому уровню абстракции. Конечно, для выполнения конкретных работ по программированию потребуются более подробные знания, специфичные для реализации (например, модель потоков), дух основной абстракции не меняется.
Вторым важным фактом является то, что как общие свойства, параллелизм и параллелизм могут сосуществовать во многих различных абстракциях.
Общее различие см. В соответствующем ответе для базового представления о параллелизме и параллелизме. (Есть также несколько ссылок, содержащих некоторые дополнительные источники.)
Параллельное программирование и параллельное программирование - это методы реализации таких общих свойств в некоторых системах, которые обеспечивают программируемость. Системы обычно являются языками программирования и их реализациями.
Язык программирования может предоставлять предполагаемые свойства по встроенным семантическим правилам. В большинстве случаев такие правила определяют оценки конкретных языковых структур (например, выражений), делая вычисление эффективно параллельным или параллельным. (Более конкретно, вычислительные эффекты, подразумеваемые оценками, могут идеально отражать эти свойства.) Однако семантика параллельного/параллельного языка по существу сложна и не является необходимой для практических работ (для реализации эффективных параллельных/параллельных алгоритмов в качестве решений реалистических задач).). Таким образом, большинство традиционных языков используют более консервативный и более простой подход: предполагая семантику оценки полностью последовательной и последовательной, а затем предоставляя необязательные примитивы, позволяющие некоторым вычислениям быть параллельными и параллельными. Эти примитивы могут быть ключевыми словами или процедурными конструкциями ("функциями"), поддерживаемыми языком. Они реализуются на основе взаимодействия с размещенными средами (ОС или "железным" аппаратным интерфейсом), обычно непрозрачным (не выводимым с помощью переносимого языка) для языка. Таким образом, в этом особом виде высокоуровневых абстракций, видимых программистами, нет ничего параллельного/параллельного, кроме этих "магических" примитивов и программ, полагающихся на эти примитивы; программисты могут наслаждаться менее подверженным ошибкам опытом программирования, когда свойства параллелизма/параллелизма не так интересны.
Хотя примитивы абстрагируют комплекс в абстракциях самого высокого уровня, реализации все еще имеют дополнительную сложность, не раскрытую языковой функцией. Итак, нужны абстракции среднего уровня. Типичным примером является многопоточность. Потоки позволяют выполнять один или несколько потоков (или просто поток; иногда его также называют процессом, который не обязательно является концепцией задачи, запланированной в ОС), поддерживаемой языковой реализацией (среда выполнения). Потоки обычно предварительно планируются во время выполнения, поэтому поток не должен ничего знать о других потоках. Таким образом, потоки естественны для реализации параллелизма до тех пор, пока они ничего не разделяют (критические ресурсы): просто разложите вычисления в разных потоках, как только базовая реализация позволяет перекрывать вычислительные ресурсы во время выполнения, это работает. Потоки также подвержены одновременному доступу к общим ресурсам: простой доступ к ресурсам в любом порядке соответствует минимальным ограничениям, требуемым алгоритмом, и реализация в конечном итоге определит, когда осуществлять доступ. В таких случаях могут потребоваться некоторые операции синхронизации. Некоторые языки рассматривают операции с потоками и синхронизацией как части высокоуровневой абстракции и представляют их как примитивы, в то время как некоторые другие языки поощряют только относительно более высокоуровневые примитивы (например, futures/promises).
На уровне специфичных для языка потоков выполняется многозадачность базовой хостинговой среды (как правило, ОС). Упреждающая многозадачность на уровне ОС используется для реализации (вытесняющей) многопоточности. В некоторых средах, таких как Windows NT, основные единицы планирования (задачи) также являются "потоками". Чтобы отличить их от реализации упомянутых выше потоков в пользовательском пространстве, они называются потоками ядра, где "ядро" означает ядро ОС (однако, строго говоря, это не совсем так для Windows NT; "настоящее" ядро) является руководителем NT). Потоки ядра не всегда сопоставляются с потоками в пространстве пользователя 1:1, хотя сопоставление 1:1 часто уменьшает большинство накладных расходов на сопоставление. Поскольку потоки ядра имеют большой вес (включая системные вызовы) для создания/уничтожения/связи, в пользовательском пространстве есть не 1:1 зеленые потоки, чтобы преодолеть накладные расходы за счет затрат на отображение. Выбор отображения в зависимости от парадигмы программирования, ожидаемой в абстракции высокого уровня. Например, когда ожидается одновременное выполнение огромного числа потоков в пользовательском пространстве (например, Erlang), сопоставление 1:1 никогда не выполнимо.
В основе многозадачности ОС лежит многозадачность на уровне ISA, обеспечиваемая логическим ядром процессора. Обычно это самый низкоуровневый публичный интерфейс для программистов. Ниже этого уровня может существовать SMT. Это форма более низкого уровня многопоточности, реализуемая аппаратными средствами, но, возможно, все еще несколько программируемая - хотя обычно она доступна только производителю процессора. Обратите внимание, что аппаратный дизайн, по-видимому, отражает параллелизм, но есть также механизм параллельного планирования, позволяющий эффективно использовать внутренние аппаратные ресурсы.
На каждом упомянутом выше уровне "потоков" участвуют как параллелизм, так и параллелизм. Хотя программные интерфейсы сильно различаются, все они подчиняются свойствам, раскрытым базовой абстракцией в самом начале.
Просто поделитесь примером, который поможет подчеркнуть различие:
Параллельное программирование: Допустим, вы хотите реализовать алгоритм сортировки слиянием. Каждый раз, когда вы делите проблему на две подзадачи, у вас может быть два потока, которые их решают. Однако для выполнения шага слияния необходимо дождаться окончания этих двух потоков, поскольку для слияния требуются оба подрешения. Это "обязательное ожидание" делает эту программу параллельной.
Параллельная программа: Допустим, вы хотите сжать n текстовых файлов и создать сжатый файл для каждого из них. Вы можете иметь от 2 (до n) потоков, каждый из которых обрабатывает подмножество файлов. Когда каждый поток готов, он просто готов, ему не нужно ждать или делать что-то еще. Таким образом, поскольку различные задачи выполняются чередующимся образом в "произвольном порядке", программа является параллельной, но не параллельной.
Как кто-то еще упомянул, каждая параллельная программа является параллельной (должна быть на самом деле), но не наоборот.
по сравнению с 