Bahasa pemrograman modern dengan abstraksi pemrograman konkuren intuitif [ditutup]

Saya tertarik untuk belajar pemrograman bersamaan, dengan fokus pada level aplikasi / pengguna (bukan pemrograman sistem). Saya mencari bahasa pemrograman tingkat tinggi modern yang menyediakan abstraksi intuitif untuk menulis aplikasi bersamaan. Saya ingin fokus pada bahasa yang meningkatkan produktivitas dan menyembunyikan kompleksitas pemrograman bersamaan.

Untuk memberikan beberapa contoh, saya tidak mempertimbangkan opsi yang baik untuk menulis kode multithreaded di C, C ++, atau Java karena IMHO produktivitas saya berkurang dan model pemrograman mereka tidak intuitif. Di sisi lain, bahasa yang meningkatkan produktivitas dan menawarkan abstraksi yang lebih intuitif seperti Python dan modul multiprosesor, Erlang, Clojure, Scala, dll. Akan menjadi pilihan yang baik.

Apa yang akan Anda rekomendasikan berdasarkan pengalaman Anda dan mengapa?

EDIT: Terima kasih semuanya atas jawaban Anda yang menarik. Sulit untuk membuat kesimpulan tanpa benar-benar mencoba karena ada banyak kandidat yang baik: Erlang, Clojure, Scala, Groovy, dan mungkin Haskell. Saya memilih jawaban dengan argumen yang paling meyakinkan, tetapi saya akan mencoba semua kandidat yang baik sebelum memutuskan mana yang akan dipilih :)

Anda hampir pasti harus melihat Clojure - menurut saya itu adalah bahasa modern terbaik untuk pemrograman multi-inti dan sangat produktif.

Atribut kunci:

• Ini adalah bahasa fungsional , yang merupakan keuntungan bagi konkurensi dan kemampuan Anda untuk berkembang menggunakan abstraksi tingkat yang lebih tinggi. Ini fitur struktur data persisten sepenuhnya abadi dan urutan malas yang akan akrab bagi siapa saja dengan pengalaman dalam bahasa fungsional seperti Haskell.
• Ini fitur sistem memori transaksional perangkat lunak yang sangat baru untuk akses bebas kunci bersamaan ke keadaan bisa berubah. Membuat kode concurrency-safe seringkali sesederhana membungkusnya dalam blok (dosync ....).
• Ini adalah Lisp - yang membuatnya sangat kuat untuk metaprogramming dan pembuatan kode berbasis makro. Ini dapat membawa keuntungan produktivitas yang signifikan (esai oleh Paul Graham - "Beating The Averages")
• Ini adalah bahasa JVM - jadi Anda tidak hanya mendapatkan akses ke berbagai perpustakaan dan alat di ekosistem Java, Anda juga mendapat manfaat dari upaya rekayasa besar yang telah dilakukan untuk menjadikan JVM platform yang efektif untuk aplikasi sisi-server secara bersamaan. Untuk tujuan praktis, ini memberikan keuntungan besar dibandingkan bahasa yang tidak memiliki fondasi untuk membangun.
• Ini dinamis - yang menghasilkan kode yang sangat ringkas dan banyak produktivitas. Namun perhatikan bahwa Anda dapat menggunakan petunjuk tipe statis opsional untuk kinerja jika diperlukan.
• Bahasa ini dirancang berdasarkan abstraksi yang agak sulit untuk dijelaskan tetapi efeknya adalah Anda mendapatkan serangkaian fitur yang relatif ortogonal yang dapat Anda gabungkan untuk menyelesaikan masalah Anda. Contohnya adalah abstraksi urutan, yang memungkinkan Anda untuk menulis kode yang berhubungan dengan setiap jenis objek "berurutan" (yang mencakup segala sesuatu dari daftar, string, array Java, urutan malas tak terbatas, baris yang dibaca dari file dll.)
• Ada komunitas yang hebat - membantu, berwawasan luas tetapi yang paling penting sangat pragmatis - fokus di Clojure umumnya adalah "menyelesaikan sesuatu".

Beberapa contoh kode mini dengan kemiringan konkurensi:

;; define and launch a future to execute do-something in another thread
(def a (future (do-something)))

;; wait for the future to finish and print its return value
(println @a)

;; call two functions protected in a single STM transaction
(dosync
  (function-one)
  (function-two))

Secara khusus, ada baiknya menonton satu atau lebih video ini:

• http://www.infoq.com/presentations/Value-Identity-State-Rich-Hickey
• http://www.infoq.com/presentations/Are-We-There-Yet-Rich-Hickey
• http://www.infoq.com/presentations/Clojure-The-Art-of-Abstraction

Anda bisa mencoba D. Ini menawarkan tiga model. Saya merekomendasikan yang pertama atau kedua.

1. std.concurrency . Jika Anda menggunakan modul ini untuk semua kebutuhan konkurensi Anda, maka kombinasi bahasa dan pustaka standar memberlakukan isolasi antara utas. Utas terutama berkomunikasi melalui pengiriman pesan, dengan dukungan terbatas untuk memori bersama dengan cara yang lebih mengutamakan "keselamatan pertama" dan melarang balapan data tingkat rendah. Sayangnya dokumentasi std.concurrency perlu diperbaiki, tetapi model ini didokumentasikan dalam bab gratis dari buku Andrei Alexandrescu, "Bahasa Pemrograman D".

2. std.parallelism . Modul ini dirancang khusus untuk paralelisme multicore daripada konkurensi kasus umum. ( Konkurensi dan paralelisme bukanlah hal yang sama, meskipun konkurensi diperlukan untuk mengimplementasikan paralelisme. ) Karena seluruh titik paralelisme adalah kinerja, std.parallelism tidak membuat jaminan isolasi karena mereka akan membuat penulisan kode paralel yang efisien menjadi sulit. Namun, ini menghilangkan banyak detail tingkat rendah yang rentan kesalahan sehingga sangat sulit untuk mengacaukan jika Anda memaralisasi beban kerja yang telah Anda verifikasi secara manual saling independen.

3. core.thread adalah pembungkus tingkat rendah di atas threading API khusus OS. Baik std.concurrency dan std.parallelism menggunakannya di bawah tenda, tetapi saya hanya akan merekomendasikan menggunakannya jika Anda sedang menulis perpustakaan concurrency Anda sendiri atau menemukan beberapa kasus sudut konyol yang tidak dapat dilakukan dengan baik di baik std.parallelism atau std .concurrency. Tidak seorang pun harus menggunakan sesuatu tingkat rendah ini untuk pekerjaan sehari-hari.

Erlang jelas merupakan pilihan yang bagus, tetapi sesuatu yang sedikit lebih praktis adalah Go , bahasa baru Google.

Itu tidak begitu jauh dari bahasa umum lainnya, jadi biasanya mudah didapat jika Anda sudah tahu bahasa 'mudah' lainnya. Banyak orang membandingkannya dengan Python atau bahkan Lua dalam hal seberapa 'nyaman' itu untuk diprogram.

Lihatlah Pemrograman Paralel Microsoft untuk .net. Ini sangat intuitif.

Banyak komputer pribadi dan workstation memiliki dua atau empat core (yaitu, CPU) yang memungkinkan beberapa utas dieksekusi secara bersamaan. Komputer dalam waktu dekat diharapkan memiliki lebih banyak core secara signifikan. Untuk memanfaatkan perangkat keras hari ini dan besok, Anda dapat memparalelkan kode Anda untuk mendistribusikan pekerjaan di banyak prosesor. Di masa lalu, paralelisasi membutuhkan manipulasi tingkat rendah dari untaian dan kunci. Visual Studio 2010 dan .NET Framework 4 meningkatkan dukungan untuk pemrograman paralel dengan menyediakan runtime baru, tipe perpustakaan kelas baru, dan alat diagnostik baru. Fitur-fitur ini menyederhanakan pengembangan paralel sehingga Anda dapat menulis kode paralel yang efisien, halus, dan dapat diukur dalam idiom alami tanpa harus bekerja secara langsung dengan utas atau kumpulan utas.

Baik Erlang maupun Scala memiliki konkurensi berbasis aktor , yang menurut saya sangat intuitif dan mudah dipelajari.

Model Aktor dalam ilmu komputer adalah model matematika perhitungan konkuren yang memperlakukan "aktor" sebagai primitif universal dari komputasi digital konkuren: sebagai tanggapan terhadap pesan yang diterimanya, aktor dapat membuat keputusan lokal, membuat lebih banyak aktor, mengirim lebih banyak pesan , dan menentukan bagaimana menanggapi pesan berikutnya yang diterima ... Ini telah digunakan baik sebagai kerangka kerja untuk pemahaman teoritis tentang perhitungan, dan sebagai dasar teoritis untuk beberapa implementasi praktis dari sistem bersamaan.

Saya belajar tentang Haskell sekarang, dan membaca makalah ini telah meyakinkan saya bahwa Haskell adalah pilihan yang baik untuk pemrograman bersamaan. Karena ini murni fungsional (sistem tipe tahu apakah suatu fungsi melakukan input, output, atau membaca / memodifikasi keadaan global), ia dapat melakukan hal-hal seperti Software Transactional Memory (diringkas dengan sangat baik dalam makalah di atas) yang berperilaku sama dengan transaksi dalam database - Anda mendapatkan banyak hal baik seperti atomicity dengan hanya sedikit gula tambahan. AFAIK, benang Haskell juga sangat ringan. Selain hal-hal ini, fakta bahwa Haskell adalah fungsional murni memungkinkan bahkan tugas-tugas sederhana dijalankan secara paralel dengan sedikit lebih dari satu kata kunci (par). sumber

Bahasa GO Google memiliki beberapa alat yang menarik untuk konkurensi - itu akan menjadi hal lain yang menyenangkan untuk dicoba. Lihat: http://golang.org/doc/effective_go.html#concurrency dan bacalah sedikit untuk contoh.

Pemrograman bersamaan adalah topik besar dan hanya ada ruang untuk beberapa sorotan khusus-Go di sini.

Pemrograman serentak di banyak lingkungan dipersulit oleh kehalusan yang diperlukan untuk mengimplementasikan akses yang benar ke variabel yang dibagi. Go mendorong pendekatan berbeda di mana nilai-nilai yang dibagikan dilewatkan di saluran dan, pada kenyataannya, tidak pernah dibagikan secara aktif oleh utas terpisah dari eksekusi. Hanya satu goroutine yang memiliki akses ke nilai pada waktu tertentu. Ras data tidak dapat terjadi, berdasarkan desain. Untuk mendorong cara berpikir ini, kami telah mereduksinya menjadi slogan:

Jangan berkomunikasi dengan berbagi memori; alih-alih, bagikan memori dengan berkomunikasi.

Pendekatan ini bisa ditempuh terlalu jauh. Jumlah referensi mungkin paling baik dilakukan dengan meletakkan mutex di sekitar variabel integer, misalnya. Tetapi sebagai pendekatan tingkat tinggi, menggunakan saluran untuk mengontrol akses membuatnya lebih mudah untuk menulis program yang jelas dan benar.

Salah satu cara untuk memikirkan model ini adalah dengan mempertimbangkan program khas single-threaded yang berjalan pada satu CPU. Tidak perlu sinkronisasi primitif. Sekarang jalankan instance lain seperti itu; juga tidak perlu sinkronisasi. Sekarang biarkan keduanya berkomunikasi; jika komunikasi adalah sinkronisasi, masih tidak perlu sinkronisasi lainnya. Jaringan pipa Unix, misalnya, sangat cocok dengan model ini. Meskipun pendekatan Go untuk konkurensi berasal dari Hoare's Communicating Sequential Processes (CSP), itu juga dapat dilihat sebagai jenis generalisasi yang aman dari pipa Unix ...

Dalam versi berikutnya, C # membuatnya lebih mudah daripada yang ditunjukkan diagram itu. Ada dua kata kunci baru Async dan Await.

Async digunakan sebagai pengubah fungsi dan mengatakan "operasi ini melakukan tugasnya di utas lain.

Menunggu digunakan dalam fungsi Async, dan di sinilah keajaiban terjadi. Pada dasarnya Await memberi tahu kompiler untuk menjalankan operasi mengikuti kata kunci dalam utas terpisah dan menunggu hasilnya. Kode apa pun setelah panggilan tunggu berjalan setelah operasi.

JUGA, operasi menyinkronkan ke utas panggilan (jadi jika Anda melakukan operasi asynch sebagai respons terhadap klik tombol, Anda tidak perlu memposting kembali secara manual ke utas UI). Dua kata kunci kecil dan Anda mendapatkan banyak kekuatan konkurensi. Baca lebih lanjut di sini

Saya masih merekomendasikan C ++. Lebih dari mampu abstraksi yang diperlukan untuk menulis kode bersamaan yang layak. Kemungkinan besar adalah bahwa Anda hanya memiliki perpustakaan yang buruk untuk melakukan pekerjaan itu, karena perpustakaan yang baik untuk melakukan pekerjaan itu relatif baru, dan memang, pengetahuan untuk menggunakan C ++ dengan baik tidak sepenuhnya umum. TBB Intel hanya ada selama beberapa tahun, dan PPL Microsoft hanya dikirimkan sejak tahun lalu.

Jika Anda menggunakan sesuatu seperti TBB atau PPL, maka kode konkuren, yah, tidak sepenuhnya sepele untuk ditulis, sejauh konkurensi tidak pernah sepele, tetapi jauh dari sulit. Jika Anda menggunakan pthreads atau Win32 utas secara langsung, maka tidak heran Anda tidak menyukainya - Anda praktis menulis assembler dengan fungsi-fungsi seperti itu. Tetapi dengan PPL, maka Anda berbicara tentang algoritma fungsional standar yang diparalelkan untuk Anda, struktur data umum untuk akses bersamaan, dan hal-hal baik semacam itu.

Sebuah plug untuk Ada diperlukan di sini, karena memiliki semua abstraksi tingkat atas untuk paralelisme & konkurensi. atau dikenal sebagai penugasan . Juga ketika OP meminta intuitif (kriteria subyektif!) Saya pikir pendekatan yang berbeda untuk dunia java-sentris mungkin dihargai.

Saya akan menyarankan Groovy / Java / GPars jika Anda dapat berbasis JVM karena memungkinkan untuk aktor, aliran data, berkomunikasi proses sekuensial (CSP), paralelisme data, perangkat lunak memori transaksional (STM), agen, ... Intinya di sini adalah bahwa ada ada banyak model konkurensi dan paralelisme tingkat tinggi yang masing-masing memiliki "sweet spot" yang berbeda. Anda tidak ingin menggunakan model yang tidak selaras dengan solusi untuk masalah yang Anda coba buat. Bahasa dan kerangka kerja dengan hanya satu model memaksa Anda melakukan peretasan algoritma.

Tentu saja saya bisa dianggap bias karena saya kontributor Groovy dan GPars. Di sisi lain saya bekerja dengan CSP dan Python, lih. Python-CSP.

Poin selanjutnya adalah bahwa pertanyaan awal adalah tentang belajar, bukan tentang menulis sistem produksi. Jadi kombinasi Groovy / Java / GPars adalah cara yang baik untuk belajar bahkan jika pekerjaan produksi akhirnya dilakukan dalam C ++ menggunakan sesuatu seperti Just :: Thread Pro atau TBB daripada berbasis JVM.

(Beberapa tautan URL yang masuk akal harus dihapus karena panik tentang spamming oleh situs host.)

Bagaimana dengan Clojure? Anda dapat menggunakan Swing misalnya tetapi menikmati fasilitas pemrograman bersamaan Clojure? Clojure memiliki integrasi Java yang cukup baik.

Juga, sudahkah Anda mempertimbangkan kerangka Java 7 Fork / Bergabung ?

Anda mungkin juga ingin melihat perpustakaan Groovy dan GPars . GPars BTW agak mirip dengan .NET Parallel Extension yang disebutkan dalam jawaban lain, tetapi sintaksis fleksibel Groov membuatnya lebih baik dibaca dalam beberapa keadaan.

Scala telah disebutkan beberapa kali dalam pertanyaan dan jawaban, tetapi saya belum melihat referensi ke Akka yang merupakan implementasi aktor yang dapat digunakan dengan Scala dan Java.

Saya pikir itu tergantung pada apa yang sedang Anda bangun. Aplikasi desktop, atau server? Saya pernah mendengar bahwa (tetapi tidak memiliki pengalaman pribadi) node.js bagus untuk pemrograman bersamaan untuk server (baik dalam hal menulis kode dan dalam kinerja). Jika saya ingin menulis aplikasi server baru, saya mungkin akan mencobanya. Tidak yakin tentang aplikasi desktop ... Saya telah menulis cukup banyak hal dalam C # dan ada beberapa alat yang menyembunyikan kompleksitas dengan baik, meskipun untuk kasus lain Anda harus menghadapinya secara langsung.

Saya mungkin mendapat untung karena ini, tetapi apakah Anda sudah membaca bab 7 dari TAOUP ? Bagian yang saya pikirkan secara spesifik adalah thread vs proses. Saya telah menemukan bahwa konsep pemrosesan bersamaan membuat kebanyakan orang berpikir tentang utas, namun saya belum pernah melihat contoh di mana utas lebih mudah dan lebih cepat digunakan daripada memunculkan proses anak.

Anda mencari tahu semua detail penanganan konkurensi kepada orang-orang pintar yang membangun OS Anda. Sudah ada banyak metode komunikasi di tempat, dan Anda tidak perlu khawatir tentang mengunci sumber daya bersama. Pada dasarnya, utas adalah peretasan efisiensi, yang berada di bawah aturan optimasi. Jangan optimalkan jika Anda belum menguji kebutuhan.

Temukan pustaka subproses yang bagus, seperti utusan untuk python . Atau Anda bisa menulis beberapa program terpisah dalam C, dan menulis program "master" lain untuk menggunakan garpu dan pipa untuk menelurkan dan berkomunikasi dengan subproses.