Selanjutnya dalam Concurrency

Selama setahun terakhir saya telah banyak bekerja pada concurrency di Jawa dan telah membangun dan bekerja pada banyak paket bersamaan. Jadi dalam hal perkembangan di dunia konkuren, saya cukup percaya diri. Lebih lanjut saya sangat tertarik untuk belajar dan memahami lebih banyak tentang pemrograman bersamaan.

Tetapi saya tidak dapat menjawab sendiri apa selanjutnya? Apa tambahan yang harus saya pelajari atau kerjakan untuk mewarisi lebih banyak keterampilan yang terkait dengan pemrosesan multi-core. Jika ada buku bagus (baca dan nikmati 'concurrency in practice' dan 'concurrent programming in java') atau sumber daya yang terkait dengan pemrosesan Multi-core sehingga saya bisa naik ke level berikutnya?

Penafian - Saya bukan ahli konkurensi, tetapi rekan penulis saya adalah, saya menirunya :-)

Karena Anda telah membaca buku-buku Doug Lea dan Brian Goetz maka Anda pasti sudah membahas materi terbaik di luar sana sampai saat ini.

Melangkah ke depan, ada peningkatan konkurensi baru di Java 7. Kerangka Fork / Bergabung dan API NIO asinkron yang baru.

Java 8 akan memperkenalkan peningkatan konkurensi lebih lanjut dengan koleksi lambdas / paralel.

Hal lain yang perlu dilihat secara serius adalah cara-cara alternatif untuk menangani konkurensi. Untuk menjadi tumpul, pendekatan 'kunci benda yang dapat diubah' Java selalu akan rentan kesalahan, tidak peduli berapa banyak API ditingkatkan. Jadi saya merekomendasikan melihat model aktor Scala dan STM Clojure sebagai cara alternatif untuk menangani masalah konkurensi sambil mempertahankan interoperabilitas dengan Java.

[peringatan -> iklan diri] Jadi saya akan secara alami merekomendasikan buku kami yang akan datang, Pengembang Java yang Beralas , yang mencakup semua hal yang saya sebutkan di atas: -).

Jangan sampai saya lupa, Groovy juga memiliki lib Gpars yang sangat direkomendasikan, saya belum menggunakannya secara pribadi.

Bahasa pemrograman D menyediakan dua paradigma untuk pemrograman bersamaan, yang keduanya memiliki kegunaan dan agak menarik.

std.concurrency menyediakan passing pesan tanpa berbagi memori default. Semua variabel global dan statis di D adalah thread-lokal secara default dan spawndan sendtidak memungkinkan pengiriman pesan yang berisi tipuan pointer yang dapat diubah. Pembagian terbatas dapat diperoleh melalui sharedkata kunci, yang memerlukan pemeriksaan tambahan oleh sistem tipe. Di luar dialek bahasa yang aman, Anda dapat memaksa variabel global global C / Java style / shared menggunakan __gsharedkata kunci, tetapi semua taruhan dimatikan sejauh keselamatan ras. Model ini dirinci dalam bab gratis buku Andrei Alexandresu "The D Programming Language".

std.parallelism kurang aman tetapi dalam beberapa hal lebih fleksibel daripada std.concurrency dan dirancang khusus untuk data multicore dan paralelisme tugas untuk meningkatkan throughput pemrosesan data daripada konkurensi kasus umum. Ini fitur loop foreach paralel, panggilan fungsi asinkron, pengurangan paralel, dll. Ini menyediakan mekanisme untuk membuatnya lebih mudah untuk menulis kode aman-ras tetapi melakukannya masih memerlukan beberapa tingkat disiplin.

Diskusi yang lebih menyeluruh tentang dua paradigma multithreading utama dalam D dapat ditemukan di artikel saya yang baru tentang subjek ini.

Saya sangat menyarankan Anda pergi dan melihat Clojure

Pendekatan konkurensi sangat baru, dan dalam pandangan saya kemajuan yang signifikan pada apa yang Anda lihat di Jawa dan sebagian besar bahasa lainnya. Beberapa poin penting:

• Identitas dan status dipisahkan - OOP melengkapi identitas objek dengan status saat ini dalam bentuk variabel anggota yang dapat berubah. Clojure secara ketat memisahkan identitas (referensi yang dikelola) dan status (struktur data yang tidak dapat diubah) dengan cara yang secara signifikan menyederhanakan pengembangan program bersamaan yang andal.
• Struktur data abadi yang terus-menerus - karena semuanya tidak berubah, Anda dapat mengambil snapshot data / status kapan saja dan yakinlah bahwa itu tidak akan dimutasi di bawah Anda. Tapi lebih baik dari itu - mereka adalah struktur data persisten yang berbagi data dengan versi sebelumnya. Akibatnya, operasi lebih dekat ke O (1) daripada O (n) yang akan Anda bayar untuk strategi copy-on-write untuk data yang tidak dapat diubah.
• Memori transaksional perangkat lunak - daripada menggunakan kunci, Anda cukup menyertakan kode dalam blok (dosync ...) dan secara otomatis dijalankan sebagai transaksi. Tidak ada risiko kebuntuan, dan tidak perlu mengembangkan strategi penguncian yang kompleks. Ini adalah kemenangan besar, terutama jika dikombinasikan dengan struktur data yang tidak berubah di atas. Secara efektif, Clojure mengimplementasikan kontrol konkurensi multi-versi dalam STM-nya.
• Paradigma pemrograman fungsional digunakan untuk membuatnya lebih mudah untuk menulis kode konkuren yang andal. Pada dasarnya jika Anda mengambil struktur data yang tidak dapat diubah, jalankan melalui fungsi murni dan output struktur data yang tidak dapat diubah, maka kode Anda dijamin aman untuk konkurensi.

Saya sarankan menonton video ini sebagai pengantar

Lihatlah bahasa Scala, yang memanjang Java dan berjalan pada JVM. Ini meminjam gagasan "Aktor" dari Erlang, dan memberikan kemampuan yang baik untuk menangani kegagalan konkurensi.

Jika Anda ingin membawanya ke tingkat yang sama sekali baru, Anda mungkin ingin melihat pemrograman dengan CUDA .

Ini memungkinkan Anda untuk mendistribusikan algoritme Anda melalui ratusan inti pemrosesan pada kartu grafis Anda daripada beberapa inti CPU utama. Bahkan ada binding Bahasa yang tampaknya membuatnya relatif mudah untuk mempercepat bahasa tingkat tinggi seperti python menggunakan teknik GPGPU .

Memprogram Konkurensi pada JVM: Menguasai Sinkronisasi, STM, dan Aktor membahas pemrograman bersamaan dalam Scala, Clojure, JRuby dan Groovy.
Anda akan mendapatkan pemahaman yang cukup solid tentang berbagai pendekatan konkurensi.

Dimana senyummu