บทความ
เริ่ม
เริ่มเรียนรู้
JavaRush /จาวาบล็อก /Random-TH /การแปล: คำถามสัมภาษณ์ 50 อันดับแรกเรียงตามกระทู้ ส่วนที่ ...
KapChook
ระดับ
Volga

การแปล: คำถามสัมภาษณ์ 50 อันดับแรกเรียงตามกระทู้ ส่วนที่ 2

เผยแพร่ในกลุ่ม
Java-университет
ส่วนที่สองของการแปลบทความต้นฉบับคำตอบสำหรับคำถามสัมภาษณ์กระทู้ Java 50 อันดับแรกสำหรับนักศึกษาใหม่ โปรแกรมเมอร์ที่มีประสบการณ์ ส่วนที่หนึ่ง.

  1. จะตรวจสอบได้อย่างไรว่าด้ายล็อคอยู่หรือไม่?

    2. ฉันไม่รู้ว่าคุณสามารถตรวจสอบได้ว่าเธรดนั้นล็อคอยู่หรือไม่ จนกระทั่งฉันเจอคำถามนี้ในการสัมภาษณ์ทางโทรศัพท์ java.lang.Thread มีเมธอด HoldLock() ซึ่งจะคืนค่าเป็นจริงก็ต่อเมื่อเธรดปัจจุบันถือมอนิเตอร์บนวัตถุเฉพาะ

  2. จะรับการถ่ายโอนข้อมูลเธรดได้อย่างไร?

    3. การถ่ายโอนข้อมูลเธรดช่วยให้คุณทราบว่าเธรดกำลังทำอะไรอยู่ มีหลายวิธีในการรับเธรดดัมพ์ ขึ้นอยู่กับระบบปฏิบัติการ บน Windows คุณสามารถใช้คำสั่งผสม ctrl + Break บน Linux คุณสามารถใช้คำสั่ง kill -3 คุณยังสามารถใช้ยูทิลิตี jstack ได้ โดยทำงานบนรหัสกระบวนการ ซึ่งคุณสามารถค้นหาได้โดยใช้ยูทิลิตี jps อื่น

  3. พารามิเตอร์ JVM ใดที่ใช้ในการควบคุมขนาดสแต็กของเธรด

    4. นี่เป็นหนึ่งในพารามิเตอร์ -Xss ธรรมดาที่ใช้ในการควบคุมขนาดของสแต็กของเธรดใน Java

  4. ความแตกต่างระหว่างการซิงโครไนซ์และ ReentrantLock คืออะไร

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

  5. ให้ 3 เธรด T1, T2 และ T3? จะใช้ลำดับ T1, T2, T3 ได้อย่างไร

    6. ความสอดคล้องสามารถทำได้หลายวิธี แต่คุณสามารถใช้เมธอด join() เพื่อเริ่มเธรดเมื่ออีกอันหนึ่งดำเนินการเสร็จสิ้นแล้ว หากต้องการนำลำดับที่กำหนดไปใช้ คุณต้องเริ่มเธรดสุดท้ายก่อน จากนั้นจึงเรียกใช้เมธอด join() ในลำดับย้อนกลับ นั่นคือ T3 เรียก T2.join และ T2 เรียก T1.join ดังนั้น T1 จะเสร็จสิ้นก่อนและ T3 สุดท้าย .

  6. วิธีผลตอบแทนทำอะไร?

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

  7. ระดับการทำงานพร้อมกันของ ConcurrentHashMap คืออะไร?

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

  8. เซมาฟอร์คืออะไร?

    9. เซมาฟอร์เป็นซิงโครไนเซอร์รูปแบบใหม่ นี่คือสัญญาณพร้อมตัวนับ ตามหลักการแล้ว เซมาฟอร์จะควบคุมชุดสิทธิ์ แต่ละบล็อกของ gets() หากจำเป็น ก่อนที่จะได้รับสิทธิ์ จากนั้นจึงรับสิทธิ์นั้น แต่ละ release() จะเพิ่มการอนุญาต ซึ่งอาจปล่อยตัวรับการบล็อกได้ อย่างไรก็ตาม สิ่งนี้ไม่ได้ใช้ออบเจ็กต์สิทธิ์ที่แท้จริง เซมาฟอร์เพียงจัดเก็บจำนวนที่มีอยู่และดำเนินการตามนั้น Semaphore ใช้เพื่อปกป้องทรัพยากรราคาแพงซึ่งมีอยู่ในปริมาณจำกัด เช่น การเชื่อมต่อกับฐานข้อมูลที่รวมกลุ่ม

  9. จะเกิดอะไรขึ้นถ้าคิวเธรดพูลเต็มแล้วและคุณส่งงาน?

    10. หากคิวเธรดพูลเต็ม งานที่ส่งจะถูก "ปฏิเสธ" วิธีการส่งของ ThreadPoolExecutor ส่ง RejectedExecutionException หลังจากนั้นจึงเรียก RejectedExecutionHandler

  10. ความแตกต่างระหว่างวิธีการส่ง () และดำเนินการ () บนเธรดพูล?

    11. ทั้งสองวิธีเป็นวิธีการส่งงานไปยังกลุ่มเธรด แต่มีความแตกต่างกันเล็กน้อยระหว่างกัน Execute(คำสั่ง Runnable) ถูกกำหนดไว้ในอินเทอร์เฟซของ Executor และดำเนินการงานที่กำหนดในอนาคต แต่ที่สำคัญกว่านั้นคือจะไม่ส่งคืนสิ่งใดเลย ในทางกลับกัน send() เป็นวิธีการโอเวอร์โหลด โดยสามารถรับงาน Runnable และ Callable และสามารถส่งคืนออบเจ็กต์ Future ที่สามารถใช้เพื่อยกเลิกการดำเนินการและ/หรือรอผลลัพธ์ของการคำนวณ วิธีการนี้ถูกกำหนดไว้ในอินเทอร์เฟซ ExecutorService ซึ่งสืบทอดมาจากอินเทอร์เฟซของ Executor และแต่ละคลาสเธรดพูล เช่น ThreadPoolExecutor หรือ ScheduledThreadPoolExecutor สืบทอดวิธีการเหล่านี้

  11. วิธีการบล็อกคืออะไร?

    12. วิธีการบล็อกเป็นวิธีการที่บล็อกจนกว่างานจะเสร็จสมบูรณ์ ตัวอย่างเช่น วิธีการ ServerSocket ยอมรับ() บล็อกในขณะที่รอให้ไคลเอนต์เชื่อมต่อ ในที่นี้ การบล็อกหมายความว่าการควบคุมจะไม่กลับไปยังวิธีการเรียกจนกว่างานจะเสร็จสิ้น ในทางกลับกัน มีวิธีการแบบอะซิงโครนัสหรือแบบไม่บล็อกที่จะเสร็จสิ้นก่อนที่งานจะเสร็จสิ้น

  12. ด้ายสวิงปลอดภัยหรือไม่?

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

  13. ความแตกต่างระหว่าง involvedAndWait และ inurgeLater คืออะไร?

    14. นี่เป็นวิธี Swing API สองวิธีที่ช่วยให้นักพัฒนาอัปเดตส่วนประกอบ GUI จากเธรด แทนที่จะจากเธรด Event Manager InvokeAndWait() อัปเดตส่วนประกอบ GUI เช่น แถบความคืบหน้าพร้อมกัน แต่ละครั้งที่มีความคืบหน้า จะต้องอัปเดตแถบเพื่อแสดงการเปลี่ยนแปลง หากมีการติดตามความคืบหน้าในเธรดอื่น จะต้องเรียก involvedAndWait() เพื่อกำหนดเธรด Event Dispatcher เพื่ออัปเดตส่วนประกอบนั้น และ invokeLater() เป็นการเรียกแบบอะซิงโครนัสเพื่ออัปเดตส่วนประกอบ

  14. วิธี Swing API ใดที่ปลอดภัยสำหรับเธรด

    15. คำถามนี้เป็นอีกครั้งเกี่ยวกับความปลอดภัยของ Swing และเธรด แม้ว่าส่วนประกอบของ Swing จะไม่ปลอดภัยสำหรับเธรด แต่ก็มีวิธีการที่สามารถเรียกได้อย่างปลอดภัยจากหลายเธรด ฉันรู้ว่าการทาสีใหม่ () และการตรวจสอบความถูกต้องใหม่ () นั้นปลอดภัยสำหรับเธรด แต่มีวิธีการอื่นในส่วนประกอบ Swing ที่แตกต่างกัน เช่น setText() ของ JTextComponent และวิธี insert() ของ JTextArea และผนวก ()

  15. จะสร้างวัตถุที่ไม่เปลี่ยนรูปได้อย่างไร?

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

  16. ReadWriteLock คืออะไร

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

  17. สปินยุ่งคืออะไร?

    18. Busy Spin เป็นเทคนิคที่โปรแกรมเมอร์ใช้เพื่อบังคับให้เธรดรอภายใต้เงื่อนไขบางประการ ต่างจากวิธีการแบบดั้งเดิม wait(), sleep() หรือ Yield() ซึ่งเกี่ยวข้องกับการยกการควบคุมโปรเซสเซอร์ วิธีการนี้ไม่ได้ทำให้โปรเซสเซอร์พ่ายแพ้ แต่จะเรียกใช้งานลูปว่างแทน ทำไมทุกคนถึงทำเช่นนี้? เพื่อบันทึกแคชโปรเซสเซอร์ บนระบบมัลติคอร์ เป็นไปได้ที่เธรดที่ถูกระงับจะดำเนินการต่อไปบนคอร์อื่น ซึ่งหมายถึงการสร้างแคชใหม่ เพื่อหลีกเลี่ยงการสร้างใหม่ซึ่งมีค่าใช้จ่ายสูง โปรแกรมเมอร์เลือกที่จะรอน้อยลงโดยใช้การหมุนที่ไม่ว่าง

  18. ความแตกต่างระหว่างตัวแปรระเหยและอะตอมมิก?

    19. นี่เป็นคำถามที่น่าสนใจทีเดียว ในตอนแรกตัวแปรผันผวนและอะตอมมิกดูคล้ายกันมาก แต่ก็ยังแตกต่างกัน ตัวแปรผันผวนให้การรับประกันที่เกิดขึ้นก่อนว่าการเขียนจะเกิดขึ้นก่อนการเขียนครั้งต่อไป ไม่รับประกันความเป็นอะตอมมิก ตัวอย่างเช่น การดำเนินการ count++ จะไม่กลายเป็นอะตอมเพียงเพราะการนับถูกประกาศว่ามีความผันผวน ในทางกลับกัน คลาส AtomicInteger จัดเตรียมวิธีการแบบอะตอมมิกเพื่อดำเนินการที่ซับซ้อนดังกล่าวแบบอะตอม ตัวอย่างเช่น getAndIncreation() เป็นการแทนที่แบบอะตอมมิกสำหรับตัวดำเนินการเพิ่ม ซึ่งสามารถใช้เพื่อเพิ่มค่าปัจจุบันแบบอะตอมหนึ่งค่าได้ นอกจากนี้ยังมีเวอร์ชันอะตอมมิกสำหรับข้อมูลประเภทอื่นๆ ด้วย

  19. จะเกิดอะไรขึ้นหากเธรดส่งข้อยกเว้นในบล็อกที่ซิงโครไนซ์

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

  20. การล็อคแบบตรวจสอบสองครั้งของ Singleton คืออะไร?

    21. นี่เป็นหนึ่งในคำถามสัมภาษณ์ที่ได้รับความนิยมมากที่สุด แต่ถึงแม้จะได้รับความนิยม แต่โอกาสที่ผู้สมัครจะตอบคำถามนั้นก็ยังสูงถึง 50% ครึ่งหนึ่งของเวลาที่เขียนโค้ดล้มเหลว และอีกครึ่งหนึ่งอธิบายว่าโค้ดเสียหายและแก้ไขอย่างไรใน Java 1.5 นี่เป็นวิธีเก่าในการสร้างซิงเกิลตันที่ปลอดภัยสำหรับเธรดที่พยายามปรับประสิทธิภาพให้เหมาะสมโดยการบล็อกเฉพาะเมื่อมีการสร้างอินสแตนซ์ซิงเกิลตันครั้งแรก แต่เนื่องจากความซับซ้อนและความจริงที่ว่ามันใช้งานไม่ได้ใน JDK 1.4 โดยส่วนตัวแล้วฉันไม่ชอบ มัน. ถึงกระนั้น แม้ว่าคุณจะไม่ชอบแนวทางนี้ แต่ก็มีประโยชน์ที่จะรู้จากมุมมองของการสัมภาษณ์

  21. จะสร้าง Singleton ที่ปลอดภัยสำหรับเธรดได้อย่างไร

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

  22. แสดงรายการ 3 ประเพณีที่คุณติดตามในการเขียนโปรแกรมแบบขนาน?

    23. นี่เป็นคำถามโปรดของฉันเพราะฉันเชื่อว่ามีกฎบางอย่างที่ต้องปฏิบัติตามเมื่อเขียนโค้ดคู่ขนาน ซึ่งจะช่วยในเรื่องประสิทธิภาพ การดีบัก และการสนับสนุน ด้านล่างนี้เป็นกฎที่ดีที่สุด 3 ข้อที่ฉันเชื่อว่าโปรแกรมเมอร์ Java ทุกคนควรปฏิบัติตาม:
    • ตั้งชื่อกระทู้ของคุณให้มีความหมายเสมอ
      • การค้นหาจุดบกพร่องหรือการติดตามข้อยกเว้นในโค้ดคู่ขนานถือเป็นงานที่ค่อนข้างยาก OrderProcessor, QuoteProcessor หรือ TradeProcessor ดีกว่า Thread-1 มาก เธรด-2 และเธรด-3 ชื่อควรสะท้อนถึงงานที่ดำเนินการโดยเธรด กรอบงานหลักทั้งหมดและแม้แต่ JDK ก็ปฏิบัติตามกฎนี้
    • หลีกเลี่ยงการบล็อกหรือลดขอบเขตการซิงค์
      • การบล็อกมีราคาแพง และการสลับบริบทยังมีราคาแพงกว่าอีกด้วย พยายามหลีกเลี่ยงการซิงโครไนซ์และการบล็อกให้มากที่สุด และคุณจะลดส่วนที่สำคัญให้เหลือน้อยที่สุด นี่คือเหตุผลว่าทำไมฉันชอบการบล็อกแบบกำหนดเวลามากกว่าวิธีแบบกำหนดเวลา เพราะมันช่วยให้คุณควบคุมขอบเขตของการบล็อกได้อย่างสมบูรณ์
    • ระหว่างซิงโครไนซ์กับรอและแจ้งเตือน ให้เลือกซิงโครไนซ์
      • ประการแรก การซิงโครไนซ์ เช่น CountDownLatch, Semaphore, CyclicBarrier หรือ Exchanger จะทำให้การเขียนโค้ดง่ายขึ้น เป็นเรื่องยากมากที่จะใช้โฟลว์การควบคุมที่ซับซ้อนโดยใช้การรอและแจ้งเตือน ประการที่สอง คลาสเหล่านี้เขียนและดูแลรักษาโดยผู้ที่เก่งที่สุดในธุรกิจ และมีโอกาสที่ดีที่คลาสเหล่านี้จะได้รับการปรับให้เหมาะสมหรือแทนที่ด้วยโค้ดที่ดีกว่าในการเปิดตัว JDK ในอนาคต ด้วยการใช้ยูทิลิตีการซิงโครไนซ์ระดับสูง คุณจะได้รับประโยชน์เหล่านี้ทั้งหมดโดยอัตโนมัติ
    • ระหว่างคอลเลกชันที่เกิดขึ้นพร้อมกันและคอลเลกชันที่ซิงโครไนซ์ ให้เลือกคอลเลกชันที่เกิดขึ้นพร้อมกัน
      • นี่เป็นกฎง่ายๆ อีกข้อหนึ่งที่ง่ายต่อการปฏิบัติตามและเก็บเกี่ยวผลประโยชน์ คอลเลกชันที่เกิดขึ้นพร้อมกันสามารถปรับขนาดได้มากกว่าคอลเลกชันที่ซิงโครไนซ์ ดังนั้นจึงควรใช้คอลเลกชันเหล่านี้เมื่อเขียนโค้ดแบบขนาน ดังนั้นครั้งต่อไปที่คุณต้องการแผนที่ ให้คิดถึง ConcurrentHashMap ก่อนที่จะคิดถึง Hashtable

  23. จะบังคับให้เธรดเริ่มต้นได้อย่างไร?

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

  24. กรอบงาน Fork/Join คืออะไร

    25. เฟรมเวิร์ก Fork/Join ที่นำมาใช้ใน JDK 7 เป็นยูทิลิตี้อันทรงพลังที่ช่วยให้นักพัฒนาสามารถใช้ประโยชน์จากโปรเซสเซอร์หลายตัวของเซิร์ฟเวอร์สมัยใหม่ ได้รับการออกแบบมาเพื่องานที่สามารถแบ่งย่อยเป็นอนุภาคขนาดเล็กแบบวนซ้ำได้ เป้าหมายคือการใช้พลังการประมวลผลที่มีอยู่ทั้งหมดเพื่อเพิ่มประสิทธิภาพให้กับแอปพลิเคชันของคุณ ข้อได้เปรียบที่สำคัญประการหนึ่งของกรอบงานนี้คือใช้อัลกอริธึมการขโมยงาน (จากงาน - งานและขโมย - ไปจนถึงขโมย) เธรดผู้ปฏิบัติงานที่งานหมดสามารถขโมยงานจากเธรดอื่นที่ยังยุ่งอยู่ได้

  25. อะไรคือความแตกต่างระหว่างการโทรเพื่อรอ () และการนอนหลับ ()?

    26. แม้ว่าทั้งการรอและโหมดสลีปแสดงถึงการหยุดชั่วคราวในแอปพลิเคชัน Java แต่ก็เป็นอุปกรณ์สำหรับความต้องการที่แตกต่างกัน การรอใช้สำหรับการสื่อสารเธรดภายใน ซึ่งจะยอมให้ล็อกหากเงื่อนไขการรอเป็นจริง และรอการแจ้งเตือนหากการดำเนินการของเธรดอื่นทำให้เงื่อนไขการรอเป็นเท็จ ในทางกลับกัน เมธอด sleep() จะยกเลิกการทำงานของโปรเซสเซอร์หรือหยุดการทำงานของเธรดปัจจุบันตามระยะเวลาที่กำหนด การเรียก sleep() จะไม่ปลดล็อคที่เธรดปัจจุบันถืออยู่
ความคิดเห็น
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION