ถัดไปในการทำงานพร้อมกัน

สำหรับปีที่ผ่านมาฉันทำงานหลายอย่างเกี่ยวกับการทำงานพร้อมกันใน Java และมีการสร้างและทำงานบนแพคเกจพร้อมกันจำนวนมาก ดังนั้นในแง่ของการพัฒนาในโลกที่เกิดขึ้นพร้อมกันฉันค่อนข้างมั่นใจ ต่อไปฉันสนใจที่จะเรียนรู้และทำความเข้าใจเพิ่มเติมเกี่ยวกับการเขียนโปรแกรมพร้อมกัน

แต่ฉันไม่สามารถตอบตัวเองในสิ่งต่อไปได้ ฉันควรเรียนรู้อะไรเพิ่มเติมหรือทำงานเพื่อเพิ่มพูนทักษะที่เกี่ยวข้องกับการประมวลผลแบบมัลติคอร์ หากมีหนังสือดีๆ (อ่านและสนุกกับ 'การทำงานพร้อมกันในทางปฏิบัติ' และ 'การเขียนโปรแกรมพร้อมกันใน java') หรือทรัพยากรที่เกี่ยวข้องกับการประมวลผลแบบมัลติคอร์เพื่อให้ฉันสามารถไปยังระดับถัดไปได้หรือไม่

ข้อจำกัดความรับผิดชอบ - ฉันไม่ใช่ผู้เชี่ยวชาญในการทำงานพร้อมกัน แต่ผู้เขียนร่วมของฉันคือฉันกำลังทำให้เขายุ่งเหยิง :-)

เนื่องจากคุณได้อ่านหนังสือของ Doug Lea และ Brian Goetz คุณก็จะได้เนื้อหาที่ดีที่สุดในปัจจุบัน

จะมีการปรับปรุงการทำงานพร้อมกันใหม่ใน Java 7 ซึ่งเห็นได้ชัดที่สุดว่าเฟรมเวิร์ก Fork / Join และ NIO API แบบอะซิงโครนัสใหม่

Java 8 จะแนะนำการปรับปรุงพร้อมกันเพิ่มเติมกับคอลเลกชัน lambdas / ขนาน

สิ่งที่ต้องพิจารณาอย่างจริงจังก็คือวิธีทางเลือกในการจัดการกับภาวะพร้อมกัน จะทื่อวิธีการ 'ล็อคไม่แน่นอนวัตถุล็อค' ของ Java มักจะเป็นข้อผิดพลาดได้ง่ายไม่ว่า API จะดีขึ้นเท่าใด ดังนั้นฉันขอแนะนำให้ดูที่โมเดลนักแสดงของ Scala และ STM ของ Clojure เป็นวิธีทางเลือกในการจัดการกับปัญหาที่เกิดขึ้นพร้อมกันในขณะที่ยังคงใช้งานร่วมกับ Java ได้

[คำเตือน -> โฆษณาด้วยตนเอง] ดังนั้นโดยปกติฉันจะแนะนำหนังสือที่กำลังจะมาถึงของเราชื่อผู้พัฒนา Java ที่มีเหตุผลดีซึ่งครอบคลุมทุกสิ่งที่ฉันกล่าวถึงข้างต้น: -) [/ คำเตือน]

เกรงว่าฉันลืม Groovy ก็มี Gpars lib ที่แนะนำสูงฉันยังไม่ได้ใช้มันเป็นการส่วนตัว

ภาษาโปรแกรม Dให้กระบวนทัศน์สองแบบสำหรับการเขียนโปรแกรมพร้อมกันซึ่งทั้งสองอย่างนี้มีประโยชน์และค่อนข้างน่าสนใจ

std.concurrencyให้ข้อความผ่านโดยไม่มีการแชร์หน่วยความจำเริ่มต้น ตัวแปรโกลบอลและสแตติกทั้งหมดใน D เป็นเธรดโลคัลโดยดีฟอลต์และspawnและsendไม่อนุญาตให้ส่งข้อความที่มีตัวชี้ทิศทางที่ไม่แน่นอน การแชร์แบบ จำกัด สามารถทำได้ผ่านsharedคำหลักซึ่งจะเป็นการตรวจสอบเพิ่มเติมโดยระบบประเภท นอกภาษาถิ่นที่ปลอดภัยของภาษาคุณสามารถบังคับตัวแปร C / Java-style global / shared แบบคลาสสิกโดยใช้__gsharedคีย์เวิร์ด แต่การเดิมพันทั้งหมดจะถูกปิดแล้วเท่ากับความปลอดภัยของการแข่งขัน รุ่นนี้มีรายละเอียดในบทฟรีของหนังสือของ Andrei Alexandresu "ภาษา D การเขียนโปรแกรม"

std.parallelismมีความปลอดภัยน้อยกว่า แต่ในบางวิธีมีความยืดหยุ่นมากกว่า std.concurrency และมุ่งเน้นไปที่ข้อมูลแบบมัลติคอร์และความขนานของงานโดยเฉพาะเพื่อเพิ่มปริมาณงานในการประมวลผลข้อมูลมากกว่าการใช้งานพร้อมกันทั่วไป มันมีลูป foreach แบบขนาน, การเรียกใช้ฟังก์ชั่นแบบอะซิงโครนัส, การลดแบบขนาน ฯลฯ มีกลไกเพื่อให้ง่ายต่อการเขียนรหัสที่ปลอดภัยสำหรับการแข่งขัน แต่การทำเช่นนั้นยังคงต้องใช้วินัยในระดับหนึ่ง

การสนทนาอย่างละเอียดมากขึ้นเกี่ยวกับกระบวนทัศน์มัลติเธรดสองหลักใน D สามารถพบได้ในบทความล่าสุดของฉันเกี่ยวกับเรื่องนี้

ฉันขอแนะนำให้คุณไปดู Clojure

การเห็นพ้องด้วยกันเป็นเรื่องแปลกใหม่มากและในมุมมองของฉันความก้าวหน้าที่สำคัญในสิ่งที่คุณเห็นใน Java และภาษาอื่น ๆ ส่วนใหญ่ ประเด็นสำคัญบางประการ:

• ข้อมูลประจำตัวและสถานะถูกแยกออก - OOP รวบรวมข้อมูลเฉพาะตัวของวัตถุด้วยสถานะปัจจุบันในรูปแบบของตัวแปรสมาชิกที่ไม่แน่นอน Clojure แยกข้อมูลประจำตัว (การอ้างอิงที่มีการจัดการ) และสถานะ (โครงสร้างข้อมูลที่ไม่เปลี่ยนรูปแบบ) อย่างเคร่งครัดในวิธีการที่สำคัญช่วยลดความซับซ้อนของการพัฒนาโปรแกรมที่น่าเชื่อถือพร้อมกัน
• โครงสร้างข้อมูลที่ไม่เปลี่ยนรูปแบบถาวร - เนื่องจากทุกสิ่งไม่เปลี่ยนแปลงคุณสามารถถ่ายภาพข้อมูล / สถานะได้ตลอดเวลาและมั่นใจได้ว่าจะไม่ได้รับการเปลี่ยนแปลงภายใต้คุณ แต่ดีกว่านั้น - เป็นโครงสร้างข้อมูลถาวรที่ใช้ข้อมูลร่วมกับเวอร์ชันก่อนหน้า เป็นผลให้การดำเนินงานมีความใกล้ชิดกับ O (1) มากกว่า O (n) ที่คุณจะจ่ายสำหรับกลยุทธ์ copy-on-write สำหรับข้อมูลที่ไม่เปลี่ยนรูป
• ซอฟต์แวร์หน่วยความจำของทรานแซคชัน - แทนที่จะใช้ล็อคคุณเพียงแค่ใส่รหัสในบล็อก (dosync ... ) และพวกมันจะทำงานโดยอัตโนมัติเป็นธุรกรรม ไม่มีความเสี่ยงของการหยุดชะงักและไม่จำเป็นต้องพัฒนากลยุทธ์การล็อคที่ซับซ้อน นี่คือชัยชนะครั้งใหญ่โดยเฉพาะเมื่อรวมกับโครงสร้างข้อมูลที่ไม่เปลี่ยนรูปด้านบน อย่างมีประสิทธิภาพ Clojure ดำเนินการควบคุมหลายรุ่นพร้อมกันใน STM
• กระบวนทัศน์การเขียนโปรแกรมการทำงานถูกนำมาใช้เพื่อให้ง่ายต่อการเขียนรหัสที่น่าเชื่อถือพร้อมกัน โดยทั่วไปถ้าคุณใช้โครงสร้างข้อมูลที่ไม่เปลี่ยนรูปแบบให้เรียกใช้ผ่านฟังก์ชั่นที่บริสุทธิ์และส่งออกโครงสร้างข้อมูลที่ไม่เปลี่ยนรูปแบบที่แตกต่างกันแล้วรหัสของคุณรับประกันว่าจะปลอดภัยสำหรับการทำงานพร้อมกัน

ฉันขอแนะนำให้ดูวิดีโอนี้เป็นการแนะนำ

ดูภาษา Scala ซึ่งขยาย Java และรันบน JVM มันยืมแนวคิดของ "นักแสดง" จาก Erlang และให้ความสามารถที่ดีสำหรับการจัดการความล้มเหลวพร้อมกัน

หากคุณต้องการที่จะนำไปสู่ระดับใหม่ทั้งหมดคุณอาจต้องการที่จะมองเข้าไปในการเขียนโปรแกรมด้วยCUDA

สิ่งนี้ช่วยให้คุณสามารถแจกจ่ายอัลกอริทึมของคุณไปยังแกนประมวลผลหลายร้อยคอร์บนการ์ดกราฟิกของคุณแทนที่จะเป็นแกน CPU หลักสองสามตัว มีการผูกภาษาที่เห็นได้ชัดซึ่งทำให้ง่ายต่อการเร่งภาษาระดับสูงเช่นหลามโดยใช้เทคนิคGPGPU

การเขียนโปรแกรมพร้อมกันใน JVM: Mastering Synchronization, STM และ Actorsกล่าวถึงการเขียนโปรแกรมพร้อมกันใน Scala, Clojure, JRuby และ Groovy
คุณจะได้รับความเข้าใจที่ดีเกี่ยวกับวิธีการที่แตกต่างกัน

รอยยิ้มของคุณอยู่ที่ไหน