Luau แบบพาราเลล

ด้วยโมเดลการเขียนโค้ด Parallel Luau คุณสามารถรันโค้ดบนหลายกระทู้พร้อมกันได้ ซึ่งสามารถปรับปรุงประสิทธิภาพของประสบการณ์ของคุณได้เมื่อคุณขยายประสบการณ์ของคุณด้วยเนื้อหาเพิ่มเติม คุณสามารถใช้รูปแบบนี้เพื่อช่วยในการรักษาประสิทธิภาพและความปลอดภัยของสคริปต์ Luau ของคุณ

โมเดลการเขียนโปรแกรมแบบพาราเลล

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

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

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

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

แยกโค้ดออกเป็นหลายกระทู้

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

วางตัวแสดงตัวอย่าง

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

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

ยกเลิกการซิงโครไนซ์กระทู้

แม้ว่าการใส่สคริปต์ภายใต้นักแสดงจะให้ความสามารถในการดําเนินการแบบพาร์เลล โดยค่าเริ่มต้นโค้ดยังคงดําเนินการบนเธรดเดียวเรียงต่อเนื่องซึ่งไม่ปรับปรุงประสิทธิภาพการทํางานในเวลาเรียลไม่ได้คุณต้องเรียก task.desynchronize() ฟังก์ชันที่สามารถใช้งานได้ซึ่งระงับการดําเนินการของคอรูตินปัจจุบันเพื่อรันโค้ดแบบพาร์เลลและดําเนินการต่อที่โอกาสการดําเนินการแบบพาร์เลลต่อไปเพื่อสลับสคริปต์กลับไปเป็นการดําเนินการแบบเรียลไทม์ โทร task.synchronize()

หรือคุณสามารถใช้วิธี RBXScriptSignal:ConnectParallel() เมื่อต้องการกำหนดการเรียกสัญญาณกลับเพื่อรันโค้ดของคุณโดยทันทีเมื่อกระตุ้นคุณไม่จำเป็นต้องเรียก task.desynchronize() ภายในการโทรกลับสัญญาณ

ยกเลิกการซิงโครไนซ์ธread
local RunService = game:GetService("RunService")

RunService.Heartbeat:ConnectParallel(function()
	...  -- โค้ดบางส่วนที่คำนวณการอัปเดตสถานะ

	task.synchronize()

	...  -- รหัสเชิงซ้ำบางอย่างที่เปลี่ยนสถานะของตัวอย่าง
end)

สคริปต์ที่เป็นส่วนหนึ่งของนักแสดงเดียวกันมักจะดำเนินการตามลําดับด้วยความเคารพซึ่งกันและกันเสมอดังนั้นคุณจึงต้องการนักแสดงหลายคนตัวอย่างเช่น หากคุณใส่สคริปต์พฤติกรรมที่เปิดใช้งานแบบพาราเลลทั้งหมดสำหรับ NPC ของคุณในตัวแสดงบทบาทหนึ่ง พวกเขายังคงทำงานเป็นลำดับเรียงตามลำดับบนเธรดเดียว แต่หากคุณมีตัวแสดงบทบาทหลายตัวสำหรับโลจิก NPC ที่แตกต่างกัน แต่ละตัวแสดงบทบาททำงานแบบพาราเลลบนเธรดของตัวเองสำหรับข้อมูลเพิ่มเติม ดู แนวทางที่ดีที่สุด

ความปลอดภัยของスレッド

ในระหว่างการดําเนินการแบบพาร์เลลล์คุณสามารถเข้าถึงส่วนใหญ่ของลําดับชั้น DataModel ได้ตามปกติ แต่บางคุณสมบัติและฟังก์ชันของ API รหัสRoblox เอนจินสามารถตรวจพบและป้องกันการเข้าถึงเหล่านี้ได้อัตโนมัติ

สมาชิก API มีระดับความปลอดภัยของกระทู้ที่บ่งบอกว่าคุณสามารถใช้งานได้หรือไม่และอย่างไรในโค้ดปาร์เรลของคุณตามที่แสดงในตารางต่อไปนี้:

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

การสื่อสารระหว่างกระทู้คู่

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

• การส่งข้อความนักแสดง API สำหรับการส่งข้อความไปยังนักแสดงโดยใช้สคริปต์
• โครงสร้างข้อมูลตารางร่วม สำหรับการแบ่งปันข้อมูลจํานวนมากอย่างมีประสิทธิภาพระหว่างผู้แสดงบทบาทหลายรายในสถานะร่วมกัน
• การสื่อสารโมเดลข้อมูลโดยตรง สำหรับการสื่อสารแบบง่ายที่มีข้อจำกัด

คุณสามารถสนับสนุนหลายเครื่องมือเพื่อรองรับความต้องการในการสื่อสารระหว่างกระทู้ของคุณตัวอย่างเช่น คุณสามารถส่งโต๊ะร่วมผ่าน API การส่งข้อความของตัวแสดงได้

การส่งข้อความของตัวแสดง

API การส่งข้อความของตัวแสดง สามารถส่งข้อมูลไปยังตัวแสดงในโมเดลข้อมูลเดียวกันได้ ไม่ว่าจะเป็นในบริบทเซิร์ฟเวอร์หรือพาร์เลล การสื่อสารผ่าน API นี้เป็นแบบไม่ซิงโครนิซ โดยผู้ส่งไม่บล็อกจนกว่าผู้รับจะได้รับข้อความ

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

API มีวิธีต่อไปนี้:

• Actor:SendMessage() สำหรับการส่งข้อความไปยังนักแสดง
• Actor:BindToMessage() สําหรับการผูกกลับ Luau กับข้อความที่มีหัวข้อที่กำหนดในบริบทเซิร์ฟเวอร์
• Actor:BindToMessageParallel() สําหรับการผูกกลับ Luau กับข้อความที่มีหัวข้อที่กำหนดไว้ในบริบทพาร์เลล

ตัวอย่างต่อไปนี้แสดงวิธีการใช้ Actor:SendMessage() เพื่อกำหนดหัวข้อและส่งข้อความไปยังด้านส่ง:

ตัวส่งข้อความตัวอย่าง
local Workspace = game:GetService("Workspace")

-- ส่งข้อความสองข้อไปยังตัวแสดงผู้ทำงานด้วยหัวข้อ "ทักทาย"
local workerActor = Workspace.WorkerActor
workerActor:SendMessage("Greeting", "Hello World!")
workerActor:SendMessage("Greeting", "Welcome")

print("Sent messages")

ตัวอย่างต่อไปนี้แสดงวิธีการใช้ Actor:BindToMessageParallel() เพื่อผูกคอลเลกชันการโทรกลับสำหรับหัวข้อบางอย่างในบริบทปาร์เรลบนเครื่องรับ:

ตัวรับข้อความตัวอย่าง
-- รับนักแสดงที่สคริปต์นี้เป็นพ่อแม่
local actor = script:GetActor()

-- ผูกกลับสำหรับหัวข้อข้อความ "ทักทาย"
actor:BindToMessageParallel("Greeting", function(greetingString)
	print(actor.Name, "-", greetingString)
end)

print("Bound to messages")

โต๊ะร่วม

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

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

การสื่อสารโมเดลข้อมูลโดยตรง

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

ตัวอย่าง

การตรวจสอบการโค้งรังสีด้านเซิร์ฟเวอร์

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

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

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

local Workspace = game:GetService("Workspace")

local tool = script.Parent.Parent

local remoteEvent = Instance.new("RemoteEvent")  -- สร้างอีเวนต์ระยะไกลใหม่และให้เป็นพ่อของเครื่องมือ
remoteEvent.Name = "RemoteMouseEvent"  -- เปลี่ยนชื่อเพื่อให้สคริปต์ท้องถิ่นสามารถค้นหาได้
remoteEvent.Parent = tool
local remoteEventConnection  -- สร้างการอ้างอิงสำหรับการเชื่อมต่ออีเวนต์ระยะไกล

-- ฟังก์ชันที่ฟังการเหตุการณ์ระยะไกล
local function onRemoteMouseEvent(player: Player, clickLocation: CFrame)
	-- เซเรียล: ดำเนินโค้ดการตั้งค่าในเซเรียล
	local character = player.Character
	-- เพิกเฉยตัวละครของผู้ใช้ระหว่างการส่งลําแสง
	local params = RaycastParams.new()
	params.FilterType = Enum.RaycastFilterType.Exclude
	params.FilterDescendantsInstances = { character }

	-- พาราเลล: ทําการโค้งรัศมีในแบบพาราเลล
	task.desynchronize()
	local origin = tool.Handle.CFrame.Position
	local epsilon = 0.01  -- ใช้ขยายรัศมีเล็กน้อยเนื่องจากตำแหน่งการคลิกอาจจะแตกต่างจากวัตถุเล็กน้อย
	local lookDirection = (1 + epsilon) * (clickLocation.Position - origin)
	local raycastResult = Workspace:Raycast(origin, lookDirection, params)
	if raycastResult then
		local hitPart = raycastResult.Instance
		if hitPart and hitPart.Name == "block" then
			local explosion = Instance.new("Explosion")

			-- เซเรียล: รหัสด้านล่างแก้ไขสถานะนอกบทบาท
			task.synchronize()
			explosion.DestroyJointRadiusPercent = 0  -- ทำให้การระเบิดไม่เป็นอันตราย
			explosion.Position = clickLocation.Position

			-- ผู้แสดงหลายคนสามารถได้รับส่วนเดียวกันในรัศมีและตัดสินใจที่จะทำลายมัน
			-- นี่เป็นสิ่งที่ปลอดภัยอย่างสมบูรณ์ แต่จะทำให้เกิดการระเบิดสองครั้งพร้อมกันแทนที่จะเป็นครั้งเดียว
			-- การตรวจสอบคู่ต่อไปจะตรวจสอบว่าการดำเนินการได้ไปถึงส่วนนี้ก่อน
			if hitPart.Parent then
				explosion.Parent = Workspace
				hitPart:Destroy()  -- ทำลายมัน
			end
		end
	end
end

-- เชื่อมสัญญาณในรูปแบบเรียงต่อกันในตอนแรกเนื่องจากรหัสการตั้งค่าบางอย่างไม่สามารถทำงานได้พร้อมกัน
remoteEventConnection = remoteEvent.OnServerEvent:Connect(onRemoteMouseEvent)

การสร้างพื้นที่ด้านเซิร์ฟเวอร์ขั้นตอน

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

-- การดําเนินการแบบพาราเลลต้องใช้นักแสดง
-- สคริปต์นี้สร้างตัวเอง; ต้นฉบับเริ่มต้นกระบวนการในขณะที่โคลนทำหน้าที่เป็นคนงาน
local Workspace = game:GetService("Workspace")

local actor = script:GetActor()
if actor == nil then
	local workers = {}
	for i = 1, 32 do
		local actor = Instance.new("Actor")
		script:Clone().Parent = actor
		table.insert(workers, actor)
	end

	-- เป็นพ่อของนักแสดงทั้งหมดภายใต้ตัวเอง
	for _, actor in workers do
		actor.Parent = script
	end

	-- สั่งให้นักแสดงสร้างพื้นที่โดยส่งข้อความ
	-- ในตัวอย่างนี้นักแสดงจะถูกเลือกแบบสุ่ม
	task.defer(function()
		local rand = Random.new()
		local seed = rand:NextNumber()

		local sz = 10
		for x = -sz, sz do
			for y = -sz, sz do
				for z = -sz, sz do
					workers[rand:NextInteger(1, #workers)]:SendMessage("GenerateChunk", x, y, z, seed)
				end
			end
		end
	end)

	-- ออกจากสคริปต์เดิม; ส่วนที่เหลือของโค้ดทำงานในแต่ละตัวแสดง
	return
end

function makeNdArray(numDim, size, elemValue)
	if numDim == 0 then
		return elemValue
	end
	local result = {}
	for i = 1, size do
		result[i] = makeNdArray(numDim - 1, size, elemValue)
	end
	return result
end

function generateVoxelsWithSeed(xd, yd, zd, seed)
	local matEnums = {Enum.Material.CrackedLava, Enum.Material.Basalt, Enum.Material.Asphalt}
	local materials = makeNdArray(3, 4, Enum.Material.CrackedLava)
	local occupancy = makeNdArray(3, 4, 1)

	local rand = Random.new()

	for x = 0, 3 do
		for y = 0, 3 do
			for z = 0, 3 do
				occupancy[x + 1][y + 1][z + 1] = math.noise(xd + 0.25 * x, yd + 0.25 * y, zd + 0.25 * z)
				materials[x + 1][y + 1][z + 1] = matEnums[rand:NextInteger(1, #matEnums)]
			end
		end
	end

	return {materials = materials, occupancy = occupancy}
end

-- ผูกการเรียกคืนในบริบทการดําเนินการแบบพาร์เลลล์
actor:BindToMessageParallel("GenerateChunk", function(x, y, z, seed)
	local voxels = generateVoxelsWithSeed(x, y, z, seed)
	local corner = Vector3.new(x * 16, y * 16, z * 16)

	-- ในขณะนี้ WriteVoxels() ต้องเรียกในระหว่างขั้นตอนการสื่อสารเซียล
	task.synchronize()
	Workspace.Terrain:WriteVoxels(
		Region3.new(corner, corner + Vector3.new(16, 16, 16)),
		4,
		voxels.materials,
		voxels.occupancy
	)
end)

แนวทางที่ดีที่สุด

รหัสโปรดดูนโยบายที่ดีที่สุดต่อไปนี้เมื่อเพิ่มโค้ด Luau:

• หลีกเลี่ยงการคำนวณที่ยาวนาน — แม้แต่ในพาราเลลการคำนวณที่ยาวนานสามารถบล็อกการดำเนินการของสคริปต์อื่นและทําให้เกิดความล่าช้าหลีกเลี่ยงการใช้การเขียนโปรแกรมแบบพาราเลลเพื่อจัดการปริมาณมากของการคำนวณที่ยาวนานและไม่ยอมแพ้

  

• ใช้จํานวนผู้แสดงที่ถูกต้อง — การดำเนินการActorsแม้ว่าอุปกรณ์จะมีคอร์น้อยกว่า Actors แต่ความละเอียดช่วยให้สามารถจัดสมดุลการโหลดได้อย่างมีประสิทธิภาพมากขึ้นระหว่างคอร์

  

  นี่ไม่ได้หมายความว่าคุณควรใช้ Actors ให้มากที่สุดเท่าที่เป็นไปได้คุณควรแยกโค้ดออกเป็น Actors ตามหน่วยตรรกะแทนที่จะทำลายโค้ดที่เชื่อมโยงกับโลจิสติกที่แตกต่างกัน Actorsตัวอย่างเช่น หากคุณต้องการเปิดใช้งานการตรวจสอบการโค้งรังสี ในแบบพาราเลล คุณควรใช้ 64 Actors และอีกมากกว่าแค่ 4 แม้ว่าคุณจะเล็งไปที่ระบบ 4 คอร์ก็ตามนี่มีคุณค่าสำหรับความยืดหยุ่นของระบบและช่วยให้สามารถจัดส่งงานตามความสามารถของฮาร์ดแวร์รองได้อย่างไรก็ตาม คุณไม่ควรใช้ Actors มากเกินไปซึ่งยากต่อการบำรุงรักษา