Далее в параллельности

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

Но я не могу ответить себе, что дальше? Что еще я должен изучать или работать, чтобы унаследовать больше навыков, связанных с многоядерной обработкой. Если есть какая-нибудь хорошая книга (прочитанная и понравившаяся «Параллелизм на практике» и «Параллельное программирование в Java») или ресурс, связанный с многоядерной обработкой, чтобы я мог перейти на следующий уровень?

Отказ от ответственности - я не эксперт по параллелизму, но мой соавтор, я его попугаю :-)

Так как вы прочитали книги Дуга Ли и Брайана Гетца, вы наверняка рассмотрели лучший материал на сегодняшний день.

В будущем появятся новые усовершенствования параллелизма в Java 7. Наиболее заметно - инфраструктура Fork / Join и новые асинхронные API-интерфейсы NIO.

Java 8 представит дальнейшие улучшения параллелизма с лямбда / параллельными коллекциями.

Еще одна вещь, на которую стоит обратить серьезное внимание, это альтернативные способы борьбы с параллелизмом. Чтобы быть грубым, подход Java 'блокировать изменяемые объекты' всегда будет подвержен ошибкам, независимо от того, насколько улучшены API. Поэтому я рекомендую рассматривать модель актора Scala и STM Clojure как альтернативные способы решения проблем параллелизма при одновременном поддержании взаимодействия с Java.

[предупреждение -> самореклама] Поэтому я, естественно, порекомендую нашу будущую книгу The Well-Gounded Java Developer , которая охватывает все вещи, которые я упомянул выше: -). [/ warning]

Чтобы не забыть, в Groovy также есть очень рекомендуемая библиотека Gpars, хотя я не использовал ее лично.

Язык программирования D предоставляет две парадигмы для параллельного программирования, оба из которых имеют свое применение и довольно интересны.

std.concurrency обеспечивает передачу сообщений без разделения памяти по умолчанию. Все глобальные и статические переменные в D являются поточно-местный по умолчанию и spawnи sendне позволяют посылать сообщения, содержащие изменяемый указатель косвенность. Ограниченное совместное использование может быть получено через sharedключевое слово, что влечет за собой дополнительную проверку системой типов. Вне безопасного диалекта языка вы можете форсировать классические глобальные / общие переменные в стиле C / Java с помощью __gsharedключевого слова, но тогда все ставки не принимаются в отношении безопасности гонки. Эта модель подробно описана в бесплатной главе книги Андрея Александресу «Язык программирования D».

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

Более подробное обсуждение двух основных парадигм многопоточности в D можно найти в моей недавней статье на эту тему.

Я настоятельно рекомендую вам пойти и взглянуть на Clojure

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

• Идентичность и состояние разделены - ООП связывает идентичность объекта с его текущим состоянием в форме изменяемых переменных-членов. Clojure строго разделяет идентичность (управляемые ссылки) и состояние (неизменяемые структуры данных) таким образом, что значительно упрощает разработку надежных параллельных программ.
• Постоянные неизменяемые структуры данных - поскольку все является неизменным, вы можете в любое время сделать снимок данных / состояния и быть уверенным, что он не будет видоизменяться под вами. Но что еще лучше - это постоянные структуры данных, которые обмениваются данными с предыдущими версиями. В результате операции гораздо ближе к O (1), чем к O (n), который вы заплатили бы за стратегию копирования при записи для неизменяемых данных.
• Программная транзакционная память - вместо использования блокировок вы просто заключаете код в блок (dosync ...), и они автоматически запускаются как транзакция. Нет риска тупиков, и нет необходимости разрабатывать сложные стратегии блокировки. Это огромный выигрыш, особенно в сочетании с неизменными структурами данных, приведенными выше. По сути, Clojure внедряет управление многовариантным параллелизмом в своем STM.
• Парадигма функционального программирования используется для того, чтобы упростить написание надежного параллельного кода. В основном, если вы берете неизменную структуру данных, запускаете ее через чистую функцию и выводите другую неизменную структуру данных, тогда ваш код гарантированно безопасен для параллелизма.

Я бы посоветовал посмотреть это видео в качестве вступления

Взгляните на язык Scala, который расширяет Java и работает на JVM. Он заимствует понятие «субъекты» от Erlang и дает хорошие возможности для обработки сбоев параллелизма.

Если вы хотите поднять его на совершенно новый уровень, вы можете заняться программированием с помощью CUDA .

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

Параллельное программирование на JVM: Мастеринг синхронизации, STM и Actors обсуждает параллельное программирование в Scala, Clojure, JRuby и Groovy.
Вы получите довольно четкое представление о различных подходах к параллелизму.

Где твоя улыбка?