คำถามติดแท็ก multithreading

Multithreading อนุญาตให้มีหลายเธรดอยู่ในบริบทของกระบวนการเดียวที่แชร์ทรัพยากรเดียวกัน แต่สามารถดำเนินการได้อย่างอิสระ

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

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

6
ทรัพยากรที่ดีที่สุดในการออกแบบและพัฒนาเกมแบบมัลติเธรดหรือเกมเอ็นจิ้นคืออะไร?
ทรัพยากรที่ดีที่สุดในการออกแบบและพัฒนาเกมแบบมัลติเธรดหรือเกมเอ็นจิ้นคืออะไร? เห็นได้ชัดว่านี่เป็นที่ที่คอมพิวเตอร์มุ่งหน้าฉันตั้งใจจะศึกษาหัวข้อนี้และฉันต้องการทราบว่ามีแหล่งข้อมูลและตัวอย่างอะไรบ้าง

5
นักแสดงในเกมควรมีความรับผิดชอบในการวาดภาพตนเองหรือไม่?
ฉันยังใหม่ต่อการพัฒนาเกม แต่ไม่ได้เขียนโปรแกรม ฉัน (อีกครั้ง) เล่นกับเกมประเภท Pong โดยใช้canvasองค์ประกอบของ JavaScript ฉันสร้างPaddleวัตถุที่มีคุณสมบัติดังต่อไปนี้ ... width height x y colour ฉันยังมีPongวัตถุที่มีคุณสมบัติเช่น ... width height backgroundColour draw(). draw()วิธีการในปัจจุบันคือการรีเซ็ตcanvasและที่เป็นที่คำถามขึ้นมา ควรPaddleวัตถุมีdraw()วิธีการรับผิดชอบสำหรับการวาดภาพหรือควรdraw()ของPongวัตถุต้องรับผิดชอบสำหรับการวาดภาพของนักแสดง (ฉันคิดว่าเป็นคำที่ถูกต้องโปรดแก้ไขฉันหากฉันไม่ถูกต้อง) ฉันคิดว่ามันจะเป็น advantagous สำหรับPaddleการวาดตัวเองที่ผมยกตัวอย่างวัตถุสองและPlayer Enemyถ้ามันไม่ได้อยู่ในPongของdraw()ฉันจะต้องเขียนรหัสที่คล้ายกันสองครั้ง การปฏิบัติที่ดีที่สุดที่นี่คืออะไร? ขอบคุณ

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

8
เกมจะจัดการกับตัวละครทั้งหมดในครั้งเดียวได้อย่างไร?
คำถามนี้เป็นเพียงการได้รับความรู้เกี่ยวกับวิธีการที่เกมสามารถจัดการกับตัวละครมากมายในครั้งเดียว ฉันยังใหม่กับการเล่นเกมดังนั้นฉันจึงขอให้อภัยคุณล่วงหน้า ตัวอย่าง ฉันกำลังสร้างเกมป้องกันหอคอยที่มีช่องหอคอย 15 ช่องที่หอคอยถูกสร้างขึ้นและแต่ละหอจะยิงกระสุนออกมาในอัตราที่แน่นอน สมมติว่าทุก ๆ วินาทีมี 2 projectilesถูกสร้างขึ้นโดยแต่ละหอคอยและมีศัตรูเดินทัพในสนามรบให้บอกว่า 70 (แต่ละชนิดมีคุณลักษณะ 10 ประเภทเช่น HP, มานา ฯลฯ ซึ่งจะเปลี่ยนไปตามการเคลื่อนที่รอบ ๆ สนามรบ). สรุป จำนวนหอคอย = 15 Projectiles ที่สร้างโดยแต่ละหอคอยต่อวินาที = 2 จำนวนทั้งหมดของ Projectile ที่สร้างต่อวินาที = 30 หน่วยใน Battlefield Count = 70 ตอนนี้เกมจัดการ30 projectiles และ 70 ยูนิตโดยจัดการกับเธรด 100 หัวข้อ (ซึ่งมากเกินไปสำหรับพีซี) หรือ1 เธรดที่ย้ายทั้งหมดของพวกเขาลดค่าของพวกเขา ฯลฯ …

2
เกม Android ควรใช้เธรดกี่เธรด
อย่างน้อยที่สุดเกม OpenGL Android มีด้าย UI และด้าย Renderer GLSurfaceViewที่สร้างขึ้นโดย Renderer.onDrawFrame()ควรทำงานขั้นต่ำเพื่อรับ FPS ที่ยิ่งใหญ่ที่สุด ฟิสิกส์, AI, ฯลฯ ไม่จำเป็นต้องวิ่งทุกเฟรมดังนั้นเราสามารถใส่มันเข้าไปในเธรดอื่นได้ ตอนนี้เรามี: เธรด Renderer - อัปเดตแอนิเมชันและวาดโพลี เธรดเกม - อัปเดตลอจิกและฟิสิกส์, AI, ฯลฯ เธรด UI - การโต้ตอบกับ Android UI เท่านั้น เนื่องจากคุณไม่ต้องการบล็อกเธรด UI เลยฉันจึงรันอีกหนึ่งเธรดสำหรับตรรกะของเกม บางทีนั่นอาจไม่จำเป็นเลย มีเหตุผลในการรันตรรกะของเกมในเธรด renderer หรือไม่?

7
การคำนวณแรงโน้มถ่วงแบบมัลติเธรด 2D
ฉันกำลังสร้างเกมสำรวจอวกาศและตอนนี้ฉันเริ่มทำงานกับแรงโน้มถ่วง (ใน C # กับ XNA) แรงโน้มถ่วงยังคงต้องการการปรับแต่ง แต่ก่อนที่ฉันจะทำได้ฉันต้องจัดการกับปัญหาด้านประสิทธิภาพด้วยการคำนวณทางฟิสิกส์ของฉัน นี่คือการใช้วัตถุ 100 รายการโดยปกติแล้วการแสดงผล 1,000 รายการโดยไม่มีการคำนวณทางฟิสิกส์ได้ดีกว่า 300 FPS (ซึ่งเป็นฝา FPS ของฉัน) แต่วัตถุใด ๆ ที่มากกว่า 10 หรือมากกว่านั้นจะนำเกมมาด้วย เข่าเมื่อทำการคำนวณทางฟิสิกส์ ฉันตรวจสอบการใช้เธรดของฉันและเธรดแรกกำลังฆ่าตัวเองจากงานทั้งหมดดังนั้นฉันจึงคิดว่าฉันต้องทำการคำนวณทางฟิสิกส์ในเธรดอื่น อย่างไรก็ตามเมื่อฉันพยายามเรียกใช้เมธอดการอัปเดตของคลาส Gravity.cs ในเธรดอื่นแม้ว่าเมธอดการอัปเดตของ Gravity จะไม่มีอะไรอยู่เกมยังคงลดเหลือ 2 FPS Gravity.cs public void Update() { foreach (KeyValuePair<string, Entity> e in entityEngine.Entities) { Vector2 Force = new Vector2(); foreach …

3
เป็นเรื่องปกติหรือไม่ที่เกมจะใช้ CPU 100%?
ฉันเพิ่งใช้การจัดการอินพุตแบบมัลติเธรดในเอ็นจินเกมของฉันโดยที่โค้ดที่โพลระบบปฏิบัติการเพื่อรวบรวมข้อมูลจากมันและการประทับเวลาจะอยู่ในเธรดแยกต่างหากและแต่ละเฟรมในเธรดหลักฉันกินอินพุตที่รวบรวมไว้ เวลาของเกมลอจิก ทุกอย่างทำงานได้ แต่การตั้งค่านี้ใช้ CPU ของฉัน 100% ฉันมีสองคอร์และเพิ่มขึ้นถึง 100% ในขณะที่รันเกมของฉัน ฉันได้ตรวจสอบกับเกมอื่น ๆ เพื่อดูว่าพวกเขาทำเช่นนั้นหรือไม่ ยกตัวอย่างเช่น Skyrim และ Doom 3 นั้นใช้ได้กับซีพียูมากกว่า 60% เป็นที่ยอมรับหรือไม่สำหรับเกมที่ใช้อินพุตแบบมัลติเธรดเพื่อใช้ CPU 100%? ถ้าไม่เช่นนั้นมีเทคนิคอะไรบ้างที่เกมดังกล่าวใช้เพื่อลดการใช้ cpu โดยเธรดอินพุต?

3
หลายแพลตฟอร์มหลายเธรด: ความท้าทายที่แท้จริงคืออะไร
ในขณะที่ไลบรารี่อย่าง SDL มี API wrapper ข้ามแพลตฟอร์มสำหรับทำเกลียวฉันคิดว่ามันไร้เดียงสาที่จะคิดว่าสิ่งนี้นำไปสู่การพัฒนาเกมโดยตรงบนแพลตฟอร์มที่แตกต่างกันอย่างมากมาย (เดสก์ท็อป / มือถือ) เป็นวิธีที่ดีที่สุดในการแก้ไขปัญหาการพัฒนาด้วยวิธีนี้ (ให้ข้ามเธรด API ใด ๆ ) พิจารณาดังต่อไปนี้: จำนวนแกนที่แตกต่างกัน ความสามารถในการประมวลผลที่แตกต่างกันอย่างมากมายต่อคอร์ สถาปัตยกรรมระบบที่แตกต่างโดยทั่วไปด้วยเช่น เวลาแฝงที่แตกต่างกันสำหรับการเข้าถึงแคช RAM และ I / O ฉันรู้สึกว่าวิธีเดียวที่จะทำเช่นนี้คือการประเมินจำนวนเธรดที่อาจเรียกใช้ต่ออุปกรณ์แต่ละชิ้นที่คุณต้องการสนับสนุนและค้นหาว่าตัวหารร่วมที่ต่ำที่สุดคืออะไร อย่างไรก็ตามสิ่งนี้ยังทำให้ฉันอยู่ในความมืดตามปริมาณการประมวลผลทั้งหมดที่มี ฉันคิดว่าวิธีเดียวที่จะทำสิ่งนี้ได้อย่างมีประสิทธิภาพคือการพัฒนาอย่างแข็งขันสำหรับอุปกรณ์พกพาที่ต่ำที่สุดที่ฉันตั้งใจจะให้การสนับสนุนตลอดการพัฒนา? - เช่นตัวหารร่วมที่ต่ำที่สุด? ควรประมาณว่าเพียงพอหรือไม่ หรือจะมีมากกว่านี้? แก้ไข: โปรดให้คนอื่นเสนอประสบการณ์เพิ่มเติมเกี่ยวกับเรื่องนี้เพราะฉันไม่รู้สึกว่าคำถามของฉันได้รับการตอบอย่างเต็มที่แล้ว

6
โครงสร้างข้อมูลสำหรับการแก้ไขและเธรด?
ฉันได้รับการจัดการกับปัญหาการกระเพื่อมอัตราเฟรมกับเกมของฉันเมื่อเร็ว ๆ นี้และดูเหมือนว่าทางออกที่ดีที่สุดจะเป็นที่แนะนำโดย Glenn Fiedler (Gaffer ในเกม) ในคลาสสิกFix Your Timestep! บทความ. ตอนนี้ - ฉันใช้ขั้นตอนเวลาที่แน่นอนสำหรับการอัปเดตของฉันแล้ว ปัญหาคือฉันไม่ได้ทำการแก้ไขที่แนะนำสำหรับการเรนเดอร์ ผลที่สุดคือฉันได้รับสองเท่าหรือข้ามเฟรมหากอัตราการแสดงผลของฉันไม่ตรงกับอัตราการอัปเดตของฉัน สิ่งเหล่านี้สามารถสังเกตเห็นได้ชัดเจน ดังนั้นฉันจึงต้องการเพิ่มการแก้ไขในเกมของฉัน - และฉันสนใจที่จะรู้ว่าคนอื่นมีโครงสร้างข้อมูลและรหัสของพวกเขาเพื่อสนับสนุนสิ่งนี้อย่างไร เห็นได้ชัดว่าฉันจะต้องจัดเก็บ (ที่ไหน / อย่างไร?) ข้อมูลสถานะเกมสองชุดที่เกี่ยวข้องกับโหมดแสดงภาพของฉันเพื่อให้สามารถแก้ไขระหว่างพวกเขาได้ นอกจากนี้ - นี่เป็นสถานที่ที่เหมาะสำหรับเพิ่มเธรด ฉันคิดว่าเธรดการอัปเดตสามารถทำงานในสถานะเกมที่สามได้โดยปล่อยให้อีกสองสำเนาเป็นแบบอ่านอย่างเดียวสำหรับเธรดการแสดงผล (นี่เป็นความคิดที่ดีใช่ไหม) มันดูเหมือนว่าจะมีสองหรือสามรุ่นของรัฐของเกมสามารถนำประสิทธิภาพการทำงานและ - ไกลที่สำคัญกว่า - ความน่าเชื่อถือและผลิตพัฒนาปัญหาเมื่อเทียบกับมีเพียงรุ่นเดียว ดังนั้นฉันจึงสนใจเป็นพิเศษในวิธีการลดปัญหาเหล่านั้น โดยเฉพาะอย่างยิ่งผมคิดว่าเป็นปัญหาของวิธีจัดการกับการเพิ่มและลบวัตถุออกจากสถานะเกม ในที่สุดดูเหมือนว่าบางรัฐอาจไม่จำเป็นต้องทำการเรนเดอร์โดยตรงหรืออาจจะยากเกินกว่าที่จะติดตามเวอร์ชั่นต่าง ๆ ของ (เช่น: เอ็นจิ้นฟิสิกส์ของบุคคลที่สามที่เก็บสถานะเดี่ยว) - ดังนั้นฉันสนใจที่จะทราบ ผู้คนจัดการข้อมูลประเภทนั้นภายในระบบดังกล่าว

4
ฉันจะทำให้ข้อความที่ผ่านระหว่างเธรดในเอ็นจินแบบมัลติเธรดยุ่งยากน้อยลงได้อย่างไร?
เอ็นจิ้น C ++ ที่ฉันกำลังทำงานอยู่นั้นแบ่งออกเป็นหลายเธรดขนาดใหญ่ (สำหรับการสร้างเนื้อหาขั้นตอนของฉัน), การเล่นเกม (สำหรับ AI, สคริปต์, การจำลอง), ฟิสิกส์และการแสดงผล เธรดสื่อสารกันผ่านวัตถุข้อความขนาดเล็กซึ่งส่งผ่านจากเธรดไปยังเธรด ก่อนที่จะก้าวด้ายจะประมวลผลข้อความที่เข้ามาทั้งหมด - การปรับปรุงเพื่อการแปลงเพิ่มและลบวัตถุ ฯลฯ บางครั้งหนึ่งเธรด (รุ่น) จะสร้างบางสิ่งบางอย่าง (ศิลปะ) และส่งผ่านไปยังเธรดอื่น (เรนเดอร์) สำหรับเจ้าของถาวร ในช่วงต้นกระบวนการและฉันสังเกตเห็นสิ่งที่สอง: ระบบการส่งข้อความยุ่งยาก การสร้างชนิดข้อความใหม่หมายถึงคลาสย่อยคลาสคลาสพื้นฐานของข้อความการสร้าง enum ใหม่สำหรับประเภทของมันและการเขียนตรรกะสำหรับวิธีที่เธรดควรตีความชนิดข้อความใหม่ มันเป็นความเร็วในการพัฒนาและมีแนวโน้มที่จะเกิดข้อผิดพลาดแบบผิดพลาด (Sidenote- การทำงานกับสิ่งนี้ทำให้ฉันรู้สึกว่าภาษาไดนามิกที่ยอดเยี่ยมสามารถเป็นเช่นนั้นได้!) มีวิธีที่ดีกว่าในการทำเช่นนี้? ฉันควรใช้บางอย่างเช่น boost :: bind เพื่อทำให้เป็นอัตโนมัติหรือไม่ ฉันเป็นห่วงว่าถ้าฉันทำอย่างนั้นฉันจะสูญเสียความสามารถในการพูดจัดเรียงข้อความตามประเภทหรือบางสิ่งบางอย่าง ไม่แน่ใจว่าการจัดการแบบนั้นจะจำเป็นหรือไม่ จุดแรกมีความสำคัญเนื่องจากเธรดเหล่านี้สื่อสารกันมาก การสร้างและส่งข้อความเป็นส่วนสำคัญในการทำให้สิ่งต่าง ๆ เกิดขึ้น ฉันต้องการที่จะปรับปรุงระบบดังกล่าว แต่ยังเปิดให้กระบวนทัศน์อื่น ๆ ที่อาจเป็นประโยชน์เช่นกัน มีการออกแบบหลายเธรดที่แตกต่างกันที่ฉันควรคิดเพื่อช่วยให้ง่ายขึ้นหรือไม่ ตัวอย่างเช่นมีทรัพยากรบางอย่างที่เขียนไม่บ่อยนัก แต่มักอ่านจากหลายเธรด …

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

2
หน้าจอการโหลดที่ราบรื่นระหว่างฉาก
ฉันสร้างหน้าจอการโหลดเพื่อแสดงภาพเคลื่อนไหวขณะโหลดฉากถัดไป ฉันโหลดฉากถัดไปแบบอะซิงโครนัสด้วย: yield return SceneManager.LoadSceneAsync(scene,LoadSceneMode.Additive); และยังตั้งApplication.backgroundLoadingPriority = ThreadPriority.Low;ให้ แต่พฤติกรรมยังคงเหมือนเดิมกับการโหลดในระดับปกติ ฉันพลาดอะไรไปรึเปล่า? พฤติกรรมที่คาดหวัง: ระดับทางออกและจางหายไป หน้าจอกำลังโหลดปรากฏขึ้น เมื่อโหลดเสร็จแล้วหน้าจอการโหลดจะจางหายไป จางหายไปในฉากต่อไป เกิดอะไรขึ้น: ระดับทางออกและจางหายไป หน้าจอโหลดปรากฏขึ้นเป็นน้ำแข็ง ทันใดนั้นฉากใหม่ก็จางหายไป เมื่อโหลดเริ่มเกมจะหยุดเช่นเดียวกับโหลดฉากปกติ ฉันอ่านว่าคุณต้องตั้งค่าallowSceneActivation = falseเพื่อให้คุณสามารถจางหน้าจอการโหลดออกไปแล้วตั้งtrueให้เป็นอันหนึ่งอันเดียวกันให้เสร็จสิ้นการโหลด แต่การทำเช่นนี้จะทำให้เกมของฉันค้างเหมือนกับที่การดำเนินการ async ไม่เคยโหลดเสร็จ

4
RTS Game AI Thread
ฉันมีโครงการเพื่อสร้างเกมกลยุทธ์แบบเรียลไทม์ตั้งแต่เริ่มต้น ฉันยังอยู่ในช่วงเริ่มต้นของการวางแผน แต่ฉันได้เขียนโปรแกรมเล็กน้อยเพื่อดูกลไก ฉันรู้วิธีการเขียนโปรแกรม ฉันยังมีความคิดที่ดีว่าฉันจะจัดโครงสร้างคลาสเกมและ AI แบบ Rule-Based (state-machine) สำหรับเครื่องเล่นคอมพิวเตอร์อย่างไร ฉันต้องการที่จะพัฒนาหลักคำสอนซึ่งจะให้พฤติกรรมที่เฉพาะเจาะจงกับหน่วยงานที่เฉพาะเจาะจง (แต่สามารถนำมาใช้ในหลาย ๆ หน่วยในเวลาเดียวกัน) เช่น Scout, Follow the Mission Route, ดำรงตำแหน่ง (โจมตีศัตรูที่อนุมัติหรือถอยหากจม) ฯลฯ หลักคำสอนจะใช้กับหน่วยเท่านั้นจึงจะมีมุมมองของหน่วยและไม่ทราบเกี่ยวกับการจัดทำแผนที่ทั้งหมด Computer AI จะวิเคราะห์แผนที่ที่มองเห็นได้ทั้งหมดและตัดสินใจว่า Soctrine ใดที่จะกำหนดแต่ละหน่วยขึ้นอยู่กับกฎชุดอื่น ฉันกำลังทำสิ่งนี้ใน C # กับ OpenGL สำหรับตอนนี้ฉันมีไม่มากมีเพียงไม่กี่อย่างเท่านั้นในการทดสอบก่อนที่ฉันจะเริ่มต้นความคิดหลักของฉัน ฉันมีวนรอบเกมที่การประมวลผลเกมทั้งหมด (ที่ฉันจะเรียกว่าการปรับปรุงการต่อสู้การเรนเดอร์การแสดงผลและอื่น ๆ หลังจากนั้น) จะเกิดขึ้นมันจะถูกเรียกบ่อยมากถ้าแอปพลิเคชันเหตุการณ์ ตอนนี้ฉันก็สงสัย เนื่องจากจะมีหลายสิ่งหลายอย่างที่ต้องดำเนินการใน gameloop Computer AI และหน่วยงานควรเลือกการกระทำของพวกเขาในลูปนั้นหรือช้าเกินไป? ถ้าฉันต้องการให้ทุกสิ่งพร้อมกันฉันควรสร้างเธรดแยกต่างหากสำหรับคอมพิวเตอร์ AI หรือไม่ หรือแม้กระทั่งด้ายแยกสำหรับทุกหน่วย? …
14 c#  ai  multithreading 

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.