Ruby Academy · บทเรียน

Ractor

การประมวลผลแบบขนานอย่างแท้จริง

Ractor เป็นบทเรียน Ruby Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Ruby Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Ruby Academy มีบทเรียนทั้งหมด 4 บทเรียน

แร็กเตอร์คืออะไร

แร็กเตอร์ (โมเดลนักแสดงของ Ruby) คือกลไกพื้นฐานสำหรับการทำงานสอดประสานที่เพิ่มเข้ามาใน Ruby 3 และให้การทำงานแบบขนานอย่างแท้จริง แร็กเตอร์แต่ละตัวทำงานกับโค้ด Ruby ได้ด้วยตัวเอง ดังนั้นแร็กเตอร์สองตัวจึงสามารถใช้ CPU สองคอร์ในเวลาเดียวกันได้

แร็กเตอร์ไม่ใช้วัตถุที่เปลี่ยนแปลงได้ร่วมกัน จึงหลีกเลี่ยงข้อจำกัดของ GVL
แร็กเตอร์สื่อสารกันด้วยการส่งข้อความ

แร็กเตอร์ยังอยู่ในขั้นทดลอง ดังนั้น Ruby จึงพิมพ์คำเตือนเมื่อคุณใช้งาน

การสร้างแร็กเตอร์

สร้างแร็กเตอร์ด้วย Ractor.new และบล็อก บล็อกจะทำงานแบบขนาน ใช้ take เพื่อรับค่าสุดท้ายของบล็อก

r = Ractor.new do
  2 + 3
end

puts r.take

ไม่มีสถานะร่วมกัน

กฎสำคัญคือ แร็กเตอร์ไม่สามารถใช้วัตถุที่เปลี่ยนแปลงได้ร่วมกันอย่างอิสระ บล็อกของแร็กเตอร์จะไม่จับตัวแปรเฉพาะที่ภายนอกไว้เหมือนบล็อกทั่วไป คุณต้องส่งข้อมูลเข้าไปอย่างชัดเจน

การแยกออกจากกันนี้ทำให้การทำงานแบบขนานปลอดภัยโดยไม่ต้องใช้ล็อก

การส่งอาร์กิวเมนต์เข้า

อาร์กิวเมนต์ของ Ractor.new จะถูกส่งไปยังพารามิเตอร์ของบล็อก นี่เป็นวิธีที่ปลอดภัยในการส่งข้อมูลเข้าแร็กเตอร์

r = Ractor.new(10) do |x|
  x * x
end

puts r.take

การส่งข้อความ

แร็กเตอร์มีกล่องรับข้อความ ส่งข้อความด้วย ractor.send(value) และรับข้อความภายในบล็อกด้วย Ractor.receive

r = Ractor.new do
  msg = Ractor.receive
  "got: " + msg
end

r.send("hello")
puts r.take

การผลักกับการดึง

ทิศทางการสื่อสารมีสองแบบ

การผลัก: ส่ง send เข้าไปในแร็กเตอร์ แล้วอ่านด้วย Ractor.receive
การดึง: แร็กเตอร์ส่งค่าด้วย Ractor.yield แล้วโค้ดภายนอกอ่านค่าด้วย take

เมื่อนำมารวมกัน ทั้งสองแบบทำให้แร็กเตอร์สร้างสายงานต่อเนื่องได้

r = Ractor.new do
  Ractor.yield 1
  Ractor.yield 2
end

puts r.take
puts r.take

ออบเจ็กต์ที่ตรึงและใช้ร่วมกันได้

ออบเจ็กต์บางชนิดสามารถใช้ร่วมกันได้ระหว่างแร็กเตอร์ เพราะไม่สามารถเปลี่ยนแปลงได้ ได้แก่ true false nil ตัวเลข สัญลักษณ์ และออบเจ็กต์ที่ตรึงไว้ทุกระดับ

Ractor.make_shareable จะตรึงกราฟออบเจ็กต์ทั้งหมด เพื่อให้สามารถใช้ร่วมกันได้อย่างปลอดภัย

data = Ractor.make_shareable([1, 2, 3])
puts "Frozen? " + data.frozen?.to_s

การคัดลอกกับการย้าย

เมื่อส่งออบเจ็กต์ที่ไม่สามารถแชร์ร่วมกันได้ Ractor จะคัดลอกแบบลึกให้โดยค่าเริ่มต้น เพื่อให้แต่ละฝั่งมีออบเจ็กต์ของตนเอง หรือคุณสามารถย้ายออบเจ็กต์ด้วย send(obj, move: true) ซึ่งจะโอนความเป็นเจ้าของและทำให้ออบเจ็กต์ต้นฉบับใช้งานไม่ได้

การย้ายช่วยหลีกเลี่ยงต้นทุนการคัดลอกสำหรับออบเจ็กต์ขนาดใหญ่

การทำงานแบบขนาน

แบ่งงานที่ใช้ CPU หนักออกไปยัง Ractor หลายตัว แล้วรวบรวมผลลัพธ์ เนื่องจากแต่ละตัวทำงานแยกกัน จึงสามารถใช้แกนประมวลผลหลายแกนได้

ractors = (1..3).map do |n|
  Ractor.new(n) do |x|
    x * 100
  end
end

results = ractors.map(&:take)
puts "Results: " + results.join(", ")

Ractor เทียบกับเธรด

การเปรียบเทียบ:

เธรดใช้หน่วยความจำร่วมกันและต้องใช้การล็อก ส่วน Ractor แยกออกจากกันและต้องสื่อสารผ่านข้อความ
เธรดไม่สามารถทำให้งานประมวลผลของ Ruby ทำงานแบบขนานได้ แต่ Ractor ทำได้
Ractor มีกฎที่เข้มงวดกว่า จึงช่วยป้องกันข้อผิดพลาดจากการทำงานพร้อมกันได้หลายรูปแบบ

ข้อแลกเปลี่ยนคือกฎการแชร์ข้อมูลจะมีความตายตัวมากขึ้น

เมื่อใดควรใช้ Ractor

เลือกใช้ Ractor เมื่อ:

คุณมีงานที่ใช้ CPU เป็นหลักและต้องการใช้แกนประมวลผลหลายแกนภายในกระบวนการเดียว
คุณต้องการการแยกออกจากกันเพื่อหลีกเลี่ยงข้อผิดพลาดจากสถานะร่วมกัน

โปรดจำไว้ว่า Ractor ยังอยู่ในระยะทดลอง API อาจเปลี่ยนแปลง และเจมจำนวนมากยังไม่ปลอดภัยสำหรับ Ractor

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ทดสอบความเข้าใจของคุณเกี่ยวกับ Ractor

สรุป: Ractor

คุณได้เรียนรู้การทำงานแบบขนานภายในกระบวนการด้วย Ractor:

Ractor.new เรียกใช้โค้ดแบบขนาน ส่วน take ใช้รับผลลัพธ์
ส่งข้อมูลเข้าไปผ่านอาร์กิวเมนต์หรือ send และรับข้อมูลด้วย Ractor.receive
ออบเจ็กต์จะถูกคัดลอกหรือย้าย ไม่ได้แชร์กันอย่างอิสระ
Ractor.make_shareable ทำให้ข้อมูลเปลี่ยนแปลงไม่ได้เพื่อให้แชร์ได้อย่างปลอดภัย

เนื้อหานี้จบหลักสูตรการทำงานพร้อมกันของ Ruby ซึ่งครอบคลุมเธรด GVL ไฟเบอร์ และ Ractor

คำถามที่พบบ่อย

บทเรียน “Ractor” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “Ractor” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Ruby Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Ruby Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “Ractor”

การประมวลผลแบบขนานอย่างแท้จริง คุณปฏิบัติ Ruby Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Ruby Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Ruby Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “Ractor” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Ruby Academy นี้ได้ไหม

ได้ บทเรียน Ruby Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Ruby Academy