ด้านล่างนี้เป็นคำถามสัมภาษณ์ยอดนิยมที่เกี่ยวข้องกับหัวข้อ Java คุณสามารถใช้พวกเขาเพื่อเตรียมตัวสำหรับการสัมภาษณ์
1) เธรดคืออะไร?
เธรดเป็นหน่วยที่เล็กที่สุดที่ระบบปฏิบัติการสามารถดำเนินการและกำหนดเวลาได้ มันมีอยู่ในกระบวนการและเป็นหน่วยปฏิบัติการจริงในกระบวนการ โปรแกรมเมอร์สามารถตั้งโปรแกรมมัลติโปรเซสเซอร์ผ่านมันและคุณสามารถเร่งงานที่ต้องใช้การดำเนินงานมากโดยใช้มัลติเธรด ตัวอย่างเช่นหากใช้เวลา 100 มิลลิวินาทีสำหรับเธรดเพื่อให้งานเสร็จสมบูรณ์จะต้องใช้เวลาเพียง 10 มิลลิวินาทีสำหรับเธรดเพื่อให้การเปลี่ยนงานเสร็จสมบูรณ์โดยใช้เธรดสิบ Java ให้การสนับสนุนที่ยอดเยี่ยมสำหรับมัลติเธรดในระดับภาษาและยังเป็นจุดขายที่ดี สำหรับรายละเอียดเพิ่มเติมโปรดคลิกที่นี่
2) ความแตกต่างระหว่างเธรดและกระบวนการคืออะไร?
เธรดเป็นส่วนย่อยของกระบวนการ กระบวนการสามารถมีเธรดได้มากมายและแต่ละเธรดจะทำงานที่แตกต่างกันในแบบคู่ขนาน กระบวนการที่แตกต่างกันใช้ช่องว่างหน่วยความจำที่แตกต่างกันในขณะที่เธรดทั้งหมดใช้พื้นที่หน่วยความจำเดียวกัน อย่ายุ่งกับหน่วยความจำสแต็กแต่ละเธรดมีหน่วยความจำสแต็กแยกต่างหากสำหรับการจัดเก็บข้อมูลท้องถิ่น สำหรับรายละเอียดเพิ่มเติมโปรดคลิกที่นี่
3) จะใช้เธรดใน Java ได้อย่างไร?
มีสองวิธีในระดับภาษา อินสแตนซ์ของคลาส java.lang.thread เป็นเธรด แต่จำเป็นต้องเรียกอินเตอร์เฟส java.lang.runnable เพื่อดำเนินการ เนื่องจากคลาสเธรดเองเป็นอินเทอร์เฟซที่เรียกว่าคุณสามารถสืบทอด Java.lang.Thread คลาสหรือเรียกอินเตอร์เฟส Runnable โดยตรงเพื่อแทนที่เมธอด Run () เพื่อใช้เธรด สำหรับรายละเอียดเพิ่มเติมโปรดคลิกที่นี่
4) ใช้ Runnable หรือ Thread?
คำถามนี้คือการติดตามคำถามก่อนหน้า ทุกคนรู้ว่าเราสามารถใช้เธรดได้โดยสืบทอดคลาสเธรดหรือเรียกอินเทอร์เฟซ Runnable คำถามคือวิธีไหนดีกว่ากัน? ฉันควรใช้มันภายใต้สถานการณ์ใด คำถามนี้ตอบง่ายถ้าคุณรู้ว่า Java ไม่รองรับการสืบทอดหลายชั้นของคลาส แต่ช่วยให้คุณโทรหาหลายอินเทอร์เฟซ ดังนั้นหากคุณต้องการสืบทอดคลาสอื่น ๆ แน่นอนว่าจะดีกว่าที่จะเรียกอินเทอร์เฟซ Runnable สำหรับรายละเอียดเพิ่มเติมโปรดคลิกที่นี่
6) วิธีการเริ่มต้น () และ run () ความแตกต่างในคลาสเธรดคืออะไร?
คำถามนี้มักถูกถาม แต่ก็ยังสามารถแยกความเข้าใจของผู้สัมภาษณ์เกี่ยวกับรูปแบบการทำเกลียว Java จากนี้ วิธีการเริ่มต้น () ใช้เพื่อเริ่มเธรดที่สร้างขึ้นใหม่และวิธีการเรียกใช้ () เรียกว่าภายในซึ่งแตกต่างจากผลของการเรียกใช้วิธีการเรียกใช้ () โดยตรง เมื่อคุณเรียกวิธีการเรียกใช้ () มันจะถูกเรียกในเธรดดั้งเดิมเท่านั้น หากไม่มีเธรดใหม่วิธีการเริ่มต้น () จะเริ่มเธรดใหม่ สำหรับการสนทนาเพิ่มเติมโปรดคลิกที่นี่
7) อะไรคือความแตกต่างระหว่าง Runnable และ Callable ใน Java?
ทั้งงานที่เรียกใช้และเรียกได้เป็นตัวแทนที่จะดำเนินการในเธรดที่แตกต่างกัน Runnable มีให้ตั้งแต่ JDK1.0 และเพิ่ม Callable ใน JDK1.5 ความแตกต่างที่สำคัญของพวกเขาคือวิธีการโทร () ที่เรียกได้สามารถส่งคืนค่าและโยนข้อยกเว้นในขณะที่วิธีการเรียกใช้ () ของ runnable ไม่มีฟังก์ชั่นเหล่านี้ Callable สามารถส่งคืนวัตถุในอนาคตที่โหลดด้วยผลการคำนวณ บล็อกของฉันมีคำแนะนำโดยละเอียดเพิ่มเติม
8) ความแตกต่างระหว่าง Cyclicbarrier และ Countdownlatch ใน Java คืออะไร?
ทั้ง Cyclicbarrier และ Countdownlatch สามารถใช้เพื่อทำให้กลุ่มของเธรดรอเธรดอื่น ๆ ซึ่งแตกต่างจาก Cyclicbarrier, Countdownlatch ไม่สามารถนำกลับมาใช้ใหม่ได้ คลิกที่นี่เพื่อดูข้อมูลเพิ่มเติมและรหัสตัวอย่าง
9) โมเดลหน่วยความจำ Java คืออะไร?
โมเดลหน่วยความจำ Java ระบุและแนะนำโปรแกรม Java เพื่อประพฤติตัวตามสถาปัตยกรรมหน่วยความจำที่แตกต่างกันซีพียูและระบบปฏิบัติการ เป็นสิ่งสำคัญอย่างยิ่งในสถานการณ์มัลติเธรด โมเดลหน่วยความจำ Java สามารถตรวจสอบให้แน่ใจว่าการเปลี่ยนแปลงที่เกิดขึ้นโดยเธรดหนึ่งสามารถมองเห็นได้สำหรับเธรดอื่น ๆ และความสัมพันธ์เกิดขึ้นก่อน ความสัมพันธ์นี้กำหนดกฎบางอย่างเพื่อให้โปรแกรมเมอร์ชัดเจนขึ้นในการเขียนโปรแกรมพร้อมกัน ตัวอย่างเช่นการมีความสัมพันธ์ก่อนทำให้มั่นใจได้ว่า:
รหัสภายในเธรดสามารถดำเนินการตามลำดับซึ่งเรียกว่ากฎการสั่งซื้อโปรแกรม
สำหรับการล็อคเดียวกันการปลดล็อคจะต้องเกิดขึ้นก่อนการดำเนินการล็อคอื่นที่เกิดขึ้นในเวลาซึ่งเรียกว่ากฎการล็อคการจัดการ
การดำเนินการเขียนก่อนหน้านี้เพื่อความผันผวนคือก่อนการดำเนินการอ่านครั้งต่อไปของความผันผวนซึ่งเรียกว่ากฎตัวแปรผันผวน
การดำเนินการใด ๆ ภายในเธรดจะต้องเรียกหลังจากเริ่มต้น () ของเธรดนี้หรือที่เรียกว่ากฎเริ่มต้นเธรด
การดำเนินการทั้งหมดของเธรดจะถูกยกเลิกก่อนที่เธรดจะสิ้นสุดลง
การดำเนินการสิ้นสุดของวัตถุจะต้องเป็นหลังจากสร้างวัตถุซึ่งเรียกว่ากฎการเลิกจ้างวัตถุ
การถ่ายภาพ
ฉันขอแนะนำอย่างยิ่งให้คุณอ่านบทที่ 16 ของ "การฝึกการเขียนโปรแกรมพร้อมกันของ Java" เพื่อเพิ่มความเข้าใจของคุณเกี่ยวกับโมเดลหน่วยความจำ Java
10) ตัวแปรผันผวนใน Java คืออะไร?
ความผันผวนเป็นตัวดัดแปลงพิเศษที่สามารถใช้งานได้โดยตัวแปรสมาชิกเท่านั้น ในกรณีที่โปรแกรม Java พร้อมกันขาดคลาสซิงโครนัสการดำเนินการแบบมัลติเธรดในตัวแปรสมาชิกจะโปร่งใสไปยังเธรดอื่น ๆ ตัวแปรระเหยง่ายสามารถตรวจสอบให้แน่ใจว่าการดำเนินการอ่านครั้งต่อไปจะเกิดขึ้นหลังจากการดำเนินการเขียนก่อนหน้านี้ซึ่งเป็นกฎตัวแปรผันผวนของคำถามก่อนหน้า คลิกที่นี่เพื่อดูเนื้อหาที่เกี่ยวข้องกับความผันผวนเพิ่มเติม
11) ความปลอดภัยของด้ายคืออะไร? เวกเตอร์เป็นคลาสที่ปลอดภัยของเธรดหรือไม่? (ดูรายละเอียดที่นี่)
หากรหัสของคุณอยู่ในกระบวนการที่คุณอยู่มีหลายเธรดที่ทำงานในเวลาเดียวกันและเธรดเหล่านี้อาจเรียกใช้รหัสนี้ในเวลาเดียวกัน หากผลลัพธ์ของการรันแต่ละครั้งเหมือนกับผลลัพธ์ของการรันเธรดเดียวและค่าของตัวแปรอื่น ๆ จะเหมือนกับที่คาดไว้จะเป็นเธรดที่ปลอดภัย วัตถุอินสแตนซ์เดียวกันของคลาสตัวนับแบบเธรดที่ปลอดภัยจะไม่ทำให้เกิดข้อผิดพลาดในการคำนวณเมื่อใช้หลายเธรด เห็นได้ชัดว่าคุณสามารถแบ่งคลาสคอลเลกชันออกเป็นสองกลุ่มคือเธรดที่ปลอดภัยและไม่ปลอดภัย เวกเตอร์ใช้วิธีการซิงโครไนซ์เพื่อให้ได้ความปลอดภัยของเธรดในขณะที่ arraylist คล้ายกับมันไม่ปลอดภัยกับเธรด
12) สภาพการแข่งขันใน Java คืออะไร? ยกตัวอย่าง
เงื่อนไขการแข่งขันจะทำให้ข้อบกพร่องบางอย่างเกิดขึ้นในสถานการณ์ที่เกิดขึ้นพร้อมกันของโปรแกรม เมื่อมัลติเธรดแข่งขันกับทรัพยากรบางอย่างสภาพการแข่งขันจะเกิดขึ้น หากโปรแกรมแรกที่จะดำเนินการล้มเหลวและจะดำเนินการในภายหลังข้อบกพร่องที่ไม่แน่นอนบางอย่างจะปรากฏในโปรแกรมทั้งหมด ข้อบกพร่องดังกล่าวนั้นยากที่จะตรวจจับและเกิดขึ้นอีกเนื่องจากการแข่งขันแบบสุ่มระหว่างเธรด ตัวอย่างคือการประมวลผลที่ไม่เป็นระเบียบดูคำตอบสำหรับรายละเอียด
13) จะหยุดด้ายใน Java ได้อย่างไร?
Java ให้ API ที่หลากหลาย แต่ไม่ได้ให้ API สำหรับการหยุดเธรด JDK 1.0 เดิมมีวิธีการควบคุมบางอย่างเช่น Stop (), Suspend () และ Resume () แต่เนื่องจากภัยคุกคามการหยุดชะงักที่อาจเกิดขึ้นพวกเขาจึงเลิกใช้งานในรุ่น JDK ที่ตามมา หลังจากนั้นนักออกแบบของ Java API ไม่ได้ให้วิธีที่เข้ากันได้และปลอดภัยในการหยุดเธรด เมื่อใช้วิธีการเรียกใช้ () หรือการโทร () เธรดจะสิ้นสุดโดยอัตโนมัติ หากคุณต้องการจบเธรดด้วยตนเองคุณสามารถใช้ตัวแปรบูลีนผันผวนเพื่อออกจากวิธีการเรียกใช้ () ลูปหรือยกเลิกงานเพื่อขัดจังหวะเธรด คลิกที่นี่เพื่อดูรหัสตัวอย่าง
14) จะเกิดอะไรขึ้นเมื่อมีข้อยกเว้นเกิดขึ้นเมื่อเธรดกำลังทำงานอยู่?
นี่เป็นคำถามสัมภาษณ์ Java ที่ยุ่งยากมากที่ฉันพบในการสัมภาษณ์ พูดง่ายๆก็คือหากข้อยกเว้นไม่ถูกจับเธรดจะหยุดดำเนินการ
thread.uncaughtexceptionhandler เป็นอินเทอร์เฟซแบบฝังสำหรับการจัดการข้อยกเว้นที่ไม่ถูกต้องซึ่งทำให้เกิดการหยุดชะงักของเธรดอย่างฉับพลัน เมื่อข้อยกเว้นที่ไม่ได้รับการยกเว้นทำให้เธรดขัดจังหวะ JVM จะใช้ Thread.getuncaughtexceptionHandler () เพื่อสอบถาม UncaughtexceptionHandler ของเธรดและส่งผ่านเธรดและข้อยกเว้นเป็นพารามิเตอร์ไปยังวิธีการของ Handler Uncaughtexception () สำหรับการประมวลผล
15) จะแบ่งปันข้อมูลระหว่างสองเธรดได้อย่างไร?
คุณสามารถทำได้โดยการแบ่งปันวัตถุหรือใช้โครงสร้างข้อมูลที่เกิดขึ้นพร้อมกันเช่นการปิดกั้นคิว บทช่วยสอนนี้ "การสื่อสารระหว่างกันของ Java" (ซึ่งเกี่ยวข้องกับการแบ่งปันวัตถุระหว่างสองเธรด) ใช้วิธีการรอและแจ้งให้ใช้โมเดลผู้บริโภคผู้ผลิต
16) ความแตกต่างระหว่างการแจ้งเตือนและการแจ้งเตือนใน Java คืออะไร?
นี่เป็นปัญหาที่ยุ่งยากอีกประการหนึ่งเนื่องจากมัลติเธรดสามารถรอล็อคการตรวจสอบเดี่ยวและนักออกแบบ Java API ให้วิธีการแจ้งเตือนเมื่อรอให้เงื่อนไขเปลี่ยนแปลง แต่วิธีการเหล่านี้ไม่ได้ใช้งานอย่างเต็มที่ วิธีการแจ้งเตือน () ไม่สามารถปลุกเธรดที่เฉพาะเจาะจงได้ดังนั้นมันจะใช้ได้เฉพาะเมื่อมีเธรดหนึ่งรอ และแจ้งเตือน () ปลุกเธรดทั้งหมดและอนุญาตให้พวกเขาแข่งขันเพื่อล็อคเพื่อให้แน่ใจว่าอย่างน้อยหนึ่งเธรดสามารถทำงานต่อไปได้ บล็อกของฉันมีข้อมูลรายละเอียดเพิ่มเติมและรหัสตัวอย่าง
17) เหตุใดรอการแจ้งเตือนและแจ้งวิธีการไม่ได้อยู่ในคลาสเธรด?
นี่เป็นคำถามที่เกี่ยวข้องกับการออกแบบที่ตรวจสอบการรับรู้ของผู้สัมภาษณ์เกี่ยวกับระบบที่มีอยู่และสิ่งที่เป็นเรื่องธรรมดา แต่ดูเหมือนไม่มีเหตุผล เมื่อตอบคำถามเหล่านี้คุณต้องอธิบายว่าทำไมจึงเหมาะสมที่จะใส่วิธีการเหล่านี้ในคลาสวัตถุและทำไมไม่ใส่ไว้ในคลาสเธรด เหตุผลหนึ่งที่ชัดเจนคือล็อคที่จัดทำโดย Java เป็นระดับวัตถุมากกว่าระดับเธรดและแต่ละวัตถุมีล็อคที่ได้รับผ่านเธรด หากเธรดจำเป็นต้องรอล็อคบางอย่างก็สมเหตุสมผลที่จะเรียกวิธีการรอ () ในวัตถุ หากวิธีการรอ () ถูกกำหนดไว้ในคลาสเธรดมันจะไม่ชัดเจนว่าล็อคเธรดที่รออยู่ พูดง่ายๆตั้งแต่รอการแจ้งเตือนและแจ้งเตือนคือการดำเนินการระดับล็อคพวกเขาจะถูกกำหนดไว้ในคลาสวัตถุเนื่องจากล็อคเป็นของวัตถุ คุณสามารถตรวจสอบบทความนี้เพื่อเรียนรู้เพิ่มเติม
18) ตัวแปร ThreadLocal คืออะไร?
Threadlocal เป็นตัวแปรพิเศษใน Java แต่ละเธรดมี Threadlocal ซึ่งหมายความว่าแต่ละเธรดมีตัวแปรอิสระของตัวเองและเงื่อนไขการแข่งขันจะถูกกำจัดอย่างสมบูรณ์ มันเป็นวิธีที่ยอดเยี่ยมในการสร้างเธรดที่ปลอดภัยสำหรับการสร้างวัตถุที่มีราคาแพง ตัวอย่างเช่นคุณสามารถใช้ ThreadLocal เพื่อสร้าง SimpledateFormat Thread-Safe เนื่องจากคลาสนั้นมีราคาแพงในการสร้างและต้องสร้างอินสแตนซ์ที่แตกต่างกันสำหรับการโทรแต่ละครั้งดังนั้นจึงไม่คุ้มค่าที่จะใช้ในเครื่อง หากคุณให้สำเนาตัวแปรที่ไม่ซ้ำกันแต่ละเธรดมันจะปรับปรุงประสิทธิภาพอย่างมาก ขั้นแรกจำนวนวัตถุราคาแพงที่สร้างขึ้นจะลดลงด้วยการมัลติเพล็กซ์ ประการที่สองคุณจะได้รับความปลอดภัยจากด้ายโดยไม่ต้องใช้การซิงโครไนซ์หรือค่าคงที่ อีกตัวอย่างที่ดีของตัวแปรเธรดท้องถิ่นคือคลาส ThreadLocalrandom ซึ่งจะช่วยลดจำนวนวัตถุสุ่มราคาแพงที่สร้างขึ้นในสภาพแวดล้อมแบบมัลติเธรด ดูคำตอบเพื่อเรียนรู้เพิ่มเติม
19) FutureTask คืออะไร?
ในโปรแกรม Java พร้อมกัน FutureTask แสดงถึงการดำเนินการแบบอะซิงโครนัสที่สามารถยกเลิกได้ มันมีวิธีการต่าง ๆ เช่นการเริ่มต้นและยกเลิกการดำเนินการสอบถามว่าการดำเนินการเสร็จสมบูรณ์และดึงผลการดำเนินงานหรือไม่ ผลลัพธ์สามารถเรียกคืนได้เมื่อการดำเนินการเสร็จสมบูรณ์ หากการดำเนินการยังไม่เสร็จสิ้นเมธอดจะบล็อก วัตถุ FutureTask สามารถห่อวัตถุที่เรียกว่าเรียกได้และเรียกใช้งานได้ เนื่องจาก FutureTask เรียกอินเทอร์เฟซ Runnable จึงสามารถส่งไปยังผู้ดำเนินการเพื่อดำเนินการได้
20) ความแตกต่างระหว่างวิธีการขัดจังหวะและ isinterruptedd ใน Java คืออะไร?
ความแตกต่างที่สำคัญระหว่าง interrupted () และ isinterrupted () คืออดีตจะล้างสถานะการขัดจังหวะในขณะที่หลังจะไม่ กลไกการขัดจังหวะของ Java multithreading ถูกนำมาใช้กับตัวระบุภายใน Calling Thread.interrupt () เพื่อขัดจังหวะเธรดจะตั้งค่าตัวระบุอินเตอร์รัปต์เป็น TRUE เมื่อเธรดอินเตอร์รัปต์เรียกเธรดวิธีการคงที่ () เพื่อตรวจสอบสถานะการขัดจังหวะสถานะการขัดจังหวะจะถูกล้าง วิธีที่ไม่คงที่ Isinterrupted () ใช้ในการสืบค้นสถานะการขัดจังหวะของเธรดอื่นโดยไม่ต้องเปลี่ยนตัวระบุสถานะอินเตอร์รัปต์ พูดง่ายๆคือวิธีใด ๆ ที่ทำให้เกิดการขัดจังหวะการรับรู้จะล้างสถานะการขัดจังหวะ ไม่ว่าในกรณีใดสถานะอินเตอร์รัปต์ของเธรดอาจเปลี่ยนแปลงได้โดยเธรดอื่น ๆ ที่เรียกว่าการขัดจังหวะ
21) ทำไมต้องรอและแจ้งวิธีการแจ้งเตือนในบล็อกซิงโครนัส?
นี่เป็นส่วนใหญ่เป็นเพราะ Java API บังคับใช้สิ่งนี้และหากคุณไม่ทำรหัสของคุณจะทำให้เกิดข้อยกเว้นที่ผิดกฎหมาย อีกเหตุผลหนึ่งคือหลีกเลี่ยงสภาพการแข่งขันระหว่างการรอคอยและการแจ้งเตือน
22) ทำไมคุณควรตรวจสอบเงื่อนไขการรอคอยในลูป?
เธรดในสถานะการรออาจได้รับการแจ้งเตือนข้อผิดพลาดและการปลุกหลอก หากไม่ได้ตรวจสอบเงื่อนไขการรอคอยในลูปโปรแกรมจะออกโดยไม่ต้องปฏิบัติตามเงื่อนไขสิ้นสุด ดังนั้นเมื่อเธรดรอตื่นขึ้นมาก็ไม่สามารถพิจารณาได้ว่าสถานะการรอคอยเดิมยังคงถูกต้องและอาจเปลี่ยนแปลงได้ในช่วงเวลานี้หลังจากการโทรวิธีการแจ้งเตือน () และก่อนที่เธรดที่รอคอยจะตื่นขึ้นมา นี่คือเหตุผลที่การใช้วิธีการรอ () ในลูปทำงานได้ดีขึ้นคุณสามารถสร้างเทมเพลตใน Eclipse เพื่อโทรหารอและแจ้งและลองดู หากคุณต้องการเรียนรู้เพิ่มเติมเกี่ยวกับปัญหานี้ฉันขอแนะนำให้คุณอ่านบทเธรดและการซิงโครไนซ์ในหนังสือ "Java ที่มีประสิทธิภาพ"
23) อะไรคือความแตกต่างระหว่างคอลเลกชันแบบซิงโครนัสและคอลเลกชันพร้อมกันใน Java?
ทั้งคอลเลกชันแบบซิงโครนัสและคอลเลกชันที่เกิดขึ้นพร้อมกันให้คอลเลกชันแบบเธรดที่เหมาะสมสำหรับมัลติเธรดและการเกิดขึ้นพร้อมกัน แต่คอลเลกชันที่เกิดขึ้นพร้อมกันนั้นปรับขนาดได้มากขึ้น ก่อนที่ Java 1.5 โปรแกรมเมอร์จะใช้คอลเลกชันแบบซิงโครนัสเท่านั้นและเมื่อมีส่วนร่วมในการทำพร้อมกันหลายเธรดมันจะนำไปสู่การต่อสู้ขัดขวางความยืดหยุ่นของระบบ Java5 แนะนำคอลเลกชันที่เกิดขึ้นพร้อมกันเช่น ConcurrentHashMap ซึ่งไม่เพียง แต่ให้ความปลอดภัยของด้าย แต่ยังช่วยเพิ่มความสามารถในการปรับขนาดด้วยเทคโนโลยีที่ทันสมัยเช่นการแยกล็อคและโซนภายใน ดูคำตอบสำหรับรายละเอียดเพิ่มเติม
24) อะไรคือความแตกต่างระหว่างกองและสแต็กในชวา?
เหตุใดคำถามนี้จึงจัดอยู่ในคำถามสัมภาษณ์แบบมัลติเธรดและพร้อมกัน? เพราะสแต็กเป็นพื้นที่หน่วยความจำที่เกี่ยวข้องกับเธรดอย่างใกล้ชิด แต่ละเธรดมีหน่วยความจำสแต็กของตัวเองซึ่งใช้ในการจัดเก็บตัวแปรท้องถิ่นพารามิเตอร์วิธีการและการเรียกสแต็ก ตัวแปรที่เก็บไว้ในเธรดเดียวจะมองไม่เห็นกับเธรดอื่น ๆ กองเป็นพื้นที่หน่วยความจำทั่วไปที่ใช้ร่วมกันโดยเธรดทั้งหมด วัตถุถูกสร้างขึ้นในกอง เพื่อปรับปรุงประสิทธิภาพเธรดจะแคชจากกองไปยังสแต็กของตัวเอง หากหลายเธรดใช้ตัวแปรนี้อาจทำให้เกิดปัญหา ในเวลานี้ตัวแปรผันผวนสามารถมีบทบาทซึ่งต้องการเธรดในการอ่านค่าของตัวแปรจากหน่วยความจำหลัก
ดูคำตอบสำหรับรายละเอียดเพิ่มเติม
25) พูลเธรดคืออะไร? ทำไมต้องใช้มัน?
การสร้างเธรดใช้ทรัพยากรและเวลาที่มีราคาแพง หากเธรดถูกสร้างขึ้นหลังจากงานมาถึงเวลาตอบสนองจะนานขึ้นและกระบวนการสามารถสร้างเธรดจำนวน จำกัด ได้ เพื่อหลีกเลี่ยงปัญหาเหล่านี้มีหลายเธรดถูกสร้างขึ้นเพื่อตอบสนองและประมวลผลเมื่อเริ่มโปรแกรม พวกเขาเรียกว่าพูลเธรดและเธรดภายในเรียกว่าเธรดคนงาน เริ่มต้นด้วย JDK1.5 Java API ให้เฟรมเวิร์กผู้บริหารที่ให้คุณสร้างพูลเธรดที่แตกต่างกัน ตัวอย่างเช่นพูลเธรดเดียวซึ่งจัดการงานทีละงาน จำนวนพูลเธรดที่คงที่หรือพูลเธรดแคช (พูลเธรดที่ขยายได้เหมาะสำหรับหลาย ๆ โปรแกรมที่มีงานระยะสั้น) ดูบทความนี้สำหรับรายละเอียดเพิ่มเติม
26) วิธีการเขียนโค้ดเพื่อแก้ปัญหาผู้ผลิตและผู้บริโภค
ในความเป็นจริงปัญหาเธรดจำนวนมากที่คุณแก้ปัญหาเป็นของโมเดลผู้ผลิตผู้ผลิตซึ่งเป็นงานการผลิตเธรดหนึ่งรายการสำหรับการบริโภคโดยเธรดอื่น ๆ คุณต้องรู้วิธีการสื่อสารระหว่างเธรดเพื่อแก้ปัญหานี้ วิธีการที่ค่อนข้างต่ำคือการใช้การรอและแจ้งให้แก้ปัญหานี้ วิธีที่ยอดเยี่ยมมากขึ้นคือการใช้ Semaphore หรือ BlockingQueue เพื่อใช้โมเดลผู้ผลิตและผู้บริโภค บทช่วยสอนนี้ใช้มัน
27) จะหลีกเลี่ยงการหยุดชะงักได้อย่างไร?
การหยุดชะงักใน Java multithreading
การหยุดชะงักหมายถึงปรากฏการณ์ของการรอคอยซึ่งกันและกันที่เกิดจากกระบวนการสองกระบวนการขึ้นไปในระหว่างกระบวนการดำเนินการเนื่องจากการแข่งขันสำหรับทรัพยากร หากไม่มีกองกำลังภายนอกพวกเขาจะไม่สามารถดำเนินการต่อได้ นี่เป็นปัญหาร้ายแรงเนื่องจากการหยุดชะงักจะทำให้โปรแกรมของคุณระงับและไม่สามารถทำงานให้เสร็จได้ ต้องปฏิบัติตามเงื่อนไขสี่ข้อต่อไปนี้สำหรับการหยุดชะงัก:
เงื่อนไขการยกเว้นซึ่งกันและกัน: ทรัพยากรสามารถใช้งานได้ทีละกระบวนการเท่านั้น
เงื่อนไขการร้องขอและถือ: เมื่อกระบวนการบล็อกเนื่องจากการร้องขอทรัพยากรจะรักษาทรัพยากรที่ได้มา
เงื่อนไขสำหรับการไม่ลิดรอน: ทรัพยากรที่ได้รับจากกระบวนการไม่สามารถถูกลิดรอนได้จนกว่าจะสิ้นสุดการใช้งาน
เงื่อนไขการรอลูป: ความสัมพันธ์ของทรัพยากรที่รอคอยลูปเกิดขึ้นระหว่างหลายกระบวนการที่เชื่อมต่อในหัวและหาง
วิธีที่ง่ายที่สุดในการหลีกเลี่ยงการหยุดชะงักคือการป้องกันเงื่อนไขการรอลูปตั้งค่าสถานะและเรียงลำดับทรัพยากรทั้งหมดในระบบและกำหนดว่าทรัพยากรแอปพลิเคชันกระบวนการทั้งหมดจะต้องดำเนินการตามลำดับที่แน่นอน บทช่วยสอนนี้มีตัวอย่างรหัสและรายละเอียดการอภิปรายเกี่ยวกับการหลีกเลี่ยงการหยุดชะงัก
28) อะไรคือความแตกต่างระหว่างล็อคสดและการหยุดชะงักใน Java?
นี่คือส่วนขยายของคำถามก่อนหน้า ล็อคสดคล้ายกับการหยุดชะงัก ความแตกต่างคือสถานะของเธรดหรือกระบวนการในล็อคสดมีการเปลี่ยนแปลงอยู่ตลอดเวลา ล็อคสดถือได้ว่าเป็นความหิวชนิดพิเศษ ตัวอย่างที่เป็นจริงของล็อคสดคือเมื่อคนสองคนพบกันในทางเดินแคบ ทั้งคู่พยายามหลีกเลี่ยงซึ่งกันและกันเพื่อให้สามารถผ่านไปได้ แต่เนื่องจากทิศทางของการหลีกเลี่ยงนั้นเหมือนกันจึงไม่มีใครสามารถผ่านทางเดินในที่สุด พูดง่ายๆคือความแตกต่างที่สำคัญระหว่างล็อคสดและล็อคที่ตายแล้วคือสถานะของกระบวนการเดิมสามารถเปลี่ยนแปลงได้ แต่ไม่สามารถดำเนินการต่อไปได้
29) วิธีตรวจสอบว่าเธรดมีล็อคหรือไม่?
ฉันไม่เคยรู้เลยว่าเราสามารถตรวจพบได้จริง ๆ ว่ากระทู้มีล็อคจนกว่าฉันจะเข้าร่วมการสัมภาษณ์ทางโทรศัพท์ มีวิธีการใน java.lang.thread เรียกว่า holdslock () ซึ่งส่งคืนจริงถ้าและเฉพาะในกรณีที่เธรดปัจจุบันเป็นเจ้าของล็อคสำหรับวัตถุเฉพาะ คุณสามารถตรวจสอบบทความนี้เพื่อเรียนรู้เพิ่มเติม
30) คุณจะได้รับด้ายสแต็คใน Java ได้อย่างไร?
สำหรับระบบปฏิบัติการที่แตกต่างกันมีหลายวิธีในการรับสแต็กเธรดของกระบวนการ Java เมื่อคุณได้รับสแต็กเธรด JVM จะเก็บสถานะของเธรดทั้งหมดไว้ในไฟล์บันทึกหรือส่งออกไปยังคอนโซล ใน Windows คุณสามารถใช้การรวมปุ่ม Ctrl + Break เพื่อรับสแต็กเธรดและใช้คำสั่ง Kill -3 ใน Linux นอกจากนี้คุณยังสามารถใช้เครื่องมือ JStack เพื่อรับซึ่งทำงานบน ID เธรดและคุณสามารถใช้เครื่องมือ JPS เพื่อค้นหา ID
31) พารามิเตอร์ใดใน JVM ที่ใช้ในการควบคุมสแต็กของเธรดด้วยสแต็กขนาดเล็ก
ปัญหานี้ง่ายมากพารามิเตอร์ -XSS ใช้เพื่อควบคุมขนาดสแต็กของเธรด คุณสามารถดูรายการการกำหนดค่า JVM สำหรับข้อมูลเพิ่มเติมเกี่ยวกับพารามิเตอร์นี้
32) ความแตกต่างระหว่างการซิงโครไนซ์และ reentrantlock ใน Java คืออะไร?
Java สามารถบรรลุการกีดกันร่วมกันเป็นเวลานานผ่านคำหลักที่ซิงโครไนซ์และมีข้อเสียบางประการ ตัวอย่างเช่นคุณไม่สามารถขยายวิธีการหรือบล็อกขอบเขตอื่น ๆ นอกเหนือจากล็อคและคุณไม่สามารถยกเลิกได้ครึ่งทางเมื่อพยายามรับล็อค ฯลฯ Java 5 ให้การควบคุมที่ซับซ้อนมากขึ้นเพื่อแก้ปัญหาเหล่านี้ผ่านอินเตอร์เฟสล็อค คลาส Reentrantlock ใช้การล็อคซึ่งมีความหมายพร้อมกันและความหมายของหน่วยความจำเหมือนกันกับการซิงโครไนซ์และยังสามารถขยายได้ คุณสามารถตรวจสอบบทความนี้เพื่อเรียนรู้เพิ่มเติม
33) มีสามเธรด T1, T2 และ T3 จะทำให้แน่ใจได้อย่างไรว่าพวกเขาถูกดำเนินการตามลำดับ?
มีหลายวิธีในการเปิดใช้งานเธรดเพื่อดำเนินการตามลำดับเฉพาะในมัลติเธรด คุณสามารถใช้วิธีการเข้าร่วม () ของคลาสเธรดเพื่อเริ่มเธรดอื่นในเธรดหนึ่งและเธรดอื่นทำให้เธรดเสร็จสมบูรณ์เพื่อดำเนินการต่อ เพื่อให้แน่ใจว่าคำสั่งของสามเธรดคุณควรเริ่มต้นครั้งสุดท้ายก่อน (T3 Call T2, T2 Call T1) เพื่อให้ T1 จะเสร็จสมบูรณ์ก่อนและ T3 จะเสร็จสิ้นครั้งสุดท้าย คุณสามารถตรวจสอบบทความนี้เพื่อเรียนรู้เพิ่มเติม
34) ฟังก์ชั่นของวิธีการให้ผลผลิตในคลาสเธรดคืออะไร?
วิธีการให้ผลผลิตสามารถหยุดการทำงานของวัตถุเธรดในปัจจุบันและอนุญาตให้เธรดอื่น ๆ ที่มีลำดับความสำคัญเดียวกันในการดำเนินการ มันเป็นวิธีการคงที่และมั่นใจได้ว่าเธรดปัจจุบันให้การใช้งาน CPU และไม่สามารถรับประกันได้ว่าเธรดอื่น ๆ สามารถครอบครอง CPU ได้ เธรดการดำเนินการให้ผลผลิต () อาจถูกดำเนินการทันทีหลังจากเข้าสู่สถานะหยุดชั่วคราว คลิกที่นี่เพื่อดูเพิ่มเติมเกี่ยวกับวิธีการให้ผลผลิต
35) การพร้อมกันของการเกิดขึ้นพร้อมกันใน Java คืออะไร?
COONCRANTHASHMAP แบ่งแผนที่จริงออกเป็นหลายส่วนเพื่อให้ได้ความสามารถในการปรับขนาดและความปลอดภัยของด้าย การแบ่งนี้ได้มาโดยใช้การเกิดพร้อมกันซึ่งเป็นพารามิเตอร์เสริมไปยังตัวสร้างคลาส CONCRURNETHASHMAP โดยมีค่าเริ่มต้นที่ 16 เพื่อให้สามารถหลีกเลี่ยงการโต้แย้งในสถานการณ์มัลติเธรด สำหรับการพร้อมกันและการปรับขนาดภายในเพิ่มเติมโปรดอ่านบทความของฉันว่าทำงานร่วมกันได้อย่างไรใน Java
36) Semaphore ใน Java คืออะไร?
Semaphore ใน Java เป็นคลาสการซิงโครไนซ์ใหม่ซึ่งเป็นสัญญาณการนับ แนวคิดเกี่ยวกับแนวคิด Semaphore ยังคงมีชุดใบอนุญาต หากจำเป็นแต่ละการได้รับ () จะถูกบล็อกก่อนที่ใบอนุญาตจะพร้อมใช้งานก่อนที่จะได้รับ แต่ละรีลีส () เพิ่มการอนุญาตซึ่งอาจปล่อยผู้ซื้อบล็อก อย่างไรก็ตามโดยไม่ต้องใช้วัตถุใบอนุญาตจริง Semaphore จะนับหมายเลขใบอนุญาตที่มีอยู่เท่านั้นและดำเนินการที่สอดคล้องกัน Semaphores มักจะใช้ในรหัสมัลติเธรดเช่นพูลเชื่อมต่อฐานข้อมูล สำหรับรายละเอียดเพิ่มเติมโปรดคลิกที่นี่
37) หากคุณส่งงานคิวพูลเธรดจะเต็ม จะเกิดอะไรขึ้นเมื่อมันเกิดขึ้น?
คำถามนี้มีฝีมือและโปรแกรมเมอร์จำนวนมากจะคิดว่างานจะบล็อกจนกว่าคิวพูลเธรดจะมีที่ว่าง ในความเป็นจริงหากไม่สามารถกำหนดงานงานได้วิธีการส่ง () ของ Threadpoolexecutor จะส่งข้อยกเว้นที่ถูกปฏิเสธ ExecutionException
38) วิธีการส่ง () และการดำเนินการ () ในพูลเธรด Java คืออะไร?
ทั้งสองวิธีสามารถส่งงานไปยังพูลเธรด ประเภทการส่งคืนของวิธีการดำเนินการ () เป็นโมฆะซึ่งกำหนดไว้ในอินเตอร์เฟสผู้ดำเนินการและวิธีการส่ง () สามารถส่งคืนวัตถุในอนาคตที่ถือผลการคำนวณ มันถูกกำหนดไว้ในอินเทอร์เฟซ ExecutorService มันขยายอินเทอร์เฟซ Executor คลาสพูลเธรดอื่น ๆ เช่น threadpoolexecutor และ scheduledThreadPoolexecutor มีวิธีการเหล่านี้ สำหรับรายละเอียดเพิ่มเติมโปรดคลิกที่นี่
39) วิธีการบล็อกคืออะไร?
วิธีการปิดกั้นหมายความว่าโปรแกรมจะรอให้วิธีการเสร็จสมบูรณ์และไม่ทำอะไรอีก วิธีการยอมรับ () ของ Serversocket คือการรอให้ลูกค้าเชื่อมต่อ การปิดกั้นที่นี่หมายความว่าเธรดปัจจุบันจะถูกระงับก่อนที่จะส่งคืนผลการโทรและจะไม่กลับมาจนกว่าจะได้ผลลัพธ์ นอกจากนี้ยังมีวิธีการแบบอะซิงโครนัสและไม่ปิดกั้นที่กลับมาก่อนที่งานจะเสร็จสมบูรณ์ สำหรับรายละเอียดเพิ่มเติมโปรดคลิกที่นี่
40) Swing Thread-Safe หรือไม่? ทำไม
คุณสามารถให้คำตอบในเชิงบวกการแกว่งไม่ปลอดภัย แต่คุณควรอธิบายว่าทำไมคำตอบนี้ถึงแม้ว่าผู้สัมภาษณ์จะไม่ถามคุณว่าทำไม เมื่อเราบอกว่าการแกว่งไม่ปลอดภัยกับด้ายมันมักจะกล่าวถึงส่วนประกอบของมันซึ่งไม่สามารถแก้ไขได้ในมัลติเธรด การอัปเดตทั้งหมดเป็นส่วนประกอบ GUI จะต้องเสร็จสิ้นในเธรด AWT Swing ให้วิธีการโทรกลับแบบซิงโครนัสและอะซิงโครนัสสองวิธีเพื่ออัปเดต คลิกที่นี่เพื่อดูเนื้อหาที่เกี่ยวข้องกับการแกว่งและความปลอดภัยของเธรดเพิ่มเติม
41) อะไรคือความแตกต่างระหว่าง Invokeandwait และ Invokelater ใน Java?
สองวิธีนี้จัดทำโดย Swing API ไปยังนักพัฒนา Java สำหรับการอัปเดตส่วนประกอบ GUI จากเธรดปัจจุบันแทนที่จะเป็นเธรดการส่งเหตุการณ์ InvokeAndWait () อัปเดตส่วนประกอบ GUI แบบซิงโครนัสเช่นแถบความคืบหน้า เมื่อความคืบหน้าได้รับการอัปเดตแถบความคืบหน้าจะต้องมีการเปลี่ยนแปลงตามลำดับ หากความคืบหน้าถูกติดตามโดยหลายเธรดเมธอด InvokeAndWait () จะถูกเรียกให้ขอเธรดการจัดส่งเหตุการณ์เพื่ออัปเดตส่วนประกอบตามนั้น เมธอด Invokelater () เรียกว่าแบบอะซิงโครนัสเพื่ออัปเดตส่วนประกอบ สำหรับรายละเอียดเพิ่มเติมโปรดคลิกที่นี่
42) วิธีการใดใน Swing API นั้นปลอดภัย
คำถามนี้ยังกล่าวถึงการแกว่งและความปลอดภัยของด้าย แม้ว่าส่วนประกอบจะไม่ปลอดภัยกับเธรด แต่ก็มีบางวิธีที่สามารถเรียกได้ว่ามัลติเธรดเช่น repaint () และ revalidate () เมธอด setText () ของ JTextComponent และวิธีการแทรก () และภาคผนวก () ของ JTextArea ยังปลอดภัยเช่นกัน
43) วิธีสร้างวัตถุที่ไม่เปลี่ยนรูปใน Java?
ปัญหานี้ดูเหมือนจะไม่มีส่วนเกี่ยวข้องกับการทำมัลติเธรด แต่ค่าความแปรปรวนช่วยลดความซับซ้อนของโปรแกรมพร้อมกันที่ซับซ้อนแล้ว วัตถุที่ไม่เปลี่ยนรูปสามารถใช้ร่วมกันได้โดยไม่ต้องซิงโครไนซ์ลดค่าใช้จ่ายในการซิงโครไนซ์เมื่อเข้าถึงวัตถุพร้อมกัน อย่างไรก็ตาม Java ไม่มีคำอธิบายประกอบ @immutable ในการสร้างคลาสที่ไม่เปลี่ยนรูปเราจำเป็นต้องใช้ขั้นตอนต่อไปนี้: เริ่มต้นสมาชิกทั้งหมดผ่านตัวสร้างไม่ได้ให้วิธีการตั้งค่ากับตัวแปรและประกาศสมาชิกทั้งหมดเป็นส่วนตัวเพื่อให้สมาชิกเหล่านี้ไม่ได้รับอนุญาตให้เข้าถึงได้โดยตรง ในวิธีการ getter อย่าส่งคืนวัตถุโดยตรง แต่โคลนวัตถุและส่งคืนสำเนาของวัตถุ บทความของฉันวิธีสร้างวัตถุที่ไม่เปลี่ยนรูปใน Java มีแบบฝึกหัดโดยละเอียดและคุณสามารถเต็มไปด้วยความมั่นใจหลังจากอ่าน
44) ReadWriteLock ใน Java คืออะไร?
โดยทั่วไปการพูดอ่านและเขียนล็อคเป็นผลมาจากเทคโนโลยีการแยกล็อคที่ใช้ในการปรับปรุงประสิทธิภาพของโปรแกรมพร้อมกัน ReadWriteLock ใน Java เป็นอินเทอร์เฟซใหม่ที่เพิ่มเข้ามาใน java 5. AdadWriteLock ยังคงล็อคคู่หนึ่งสำหรับการดำเนินการแบบอ่านอย่างเดียวและอีกอันสำหรับการเขียน ล็อคการอ่านอาจจัดขึ้นโดยหลายเธรดการอ่านในเวลาเดียวกันโดยไม่มีเธรดเขียน การเขียนล็อคเป็นเอกสิทธิ์คุณสามารถใช้กฎนี้ได้โดยใช้ ReentRantReadWriteLock ใน JDK ซึ่งรองรับการล็อคเขียนได้ถึง 65535 และ 65535 การอ่าน
45) การวนซ้ำที่วุ่นวายในมัลติเธรดคืออะไร?
ลูปไม่ว่างคือเมื่อโปรแกรมเมอร์ใช้ลูปเพื่อทำเธรดรอ ซึ่งแตกต่างจากวิธีการดั้งเดิมเช่น wait (), sleep () หรือ dielt () พวกเขาทั้งหมดให้การควบคุม CPU ในขณะที่ลูปที่ยุ่งไม่ยอมแพ้ CPU มันเป็นเพียงการวนรอบที่ว่างเปล่า จุดประสงค์ของสิ่งนี้คือเพื่อรักษาแคช CPU ในระบบมัลติคอร์หนึ่งการรอเธรดที่จะตื่นขึ้นมาอาจทำงานในเคอร์เนลอื่นซึ่งจะสร้างแคชใหม่ สามารถหลีกเลี่ยงการสร้างแคชใหม่และลดเวลารอการสร้างใหม่ คุณสามารถตรวจสอบบทความนี้สำหรับข้อมูลเพิ่มเติม
46) ความแตกต่างระหว่างตัวแปรระเหยและตัวแปรอะตอมคืออะไร?
นี่เป็นคำถามที่น่าสนใจ ก่อนอื่นตัวแปรระเหยได้นั้นดูคล้ายกับตัวแปรอะตอมมาก แต่ฟังก์ชั่นแตกต่างกัน ตัวแปรผันผวนช่วยให้มั่นใจได้ถึงความสัมพันธ์ของบรรพบุรุษนั่นคือการดำเนินการเขียนจะเกิดขึ้นก่อนการดำเนินการอ่านที่ตามมา แต่ไม่รับประกันความเป็นอะตอม ตัวอย่างเช่นการปรับเปลี่ยนตัวแปรนับด้วยความผันผวนจากนั้นการดำเนินการ Count ++ จะไม่เป็นอะตอม วิธีอะตอมที่จัดทำโดยคลาส Atomicinteger สามารถทำให้การดำเนินการนี้เป็นอะตอม ตัวอย่างเช่นวิธี getandincrement () จะดำเนินการเพิ่มขึ้นของอะตอมเพื่อเพิ่มค่าปัจจุบันโดยหนึ่งชนิดและประเภทข้อมูลอื่น ๆ และตัวแปรอ้างอิงสามารถดำเนินการที่คล้ายกัน
47) จะเกิดอะไรขึ้นถ้าเธรดภายในบล็อกการซิงโครไนซ์โยนข้อยกเว้น?
คำถามนี้ได้หลอกโปรแกรมเมอร์ Java จำนวนมาก หากคุณสามารถนึกได้ว่าล็อคปล่อยเบาะแสนี้ให้ตอบคุณยังหวังว่าจะตอบได้อย่างถูกต้อง ไม่ว่าบล็อกการซิงโครไนซ์ของคุณจะออกจากปกติหรือผิดปกติเธรดภายในจะปล่อยล็อคดังนั้นฉันชอบบล็อกการซิงโครไนซ์เมื่อเทียบกับอินเทอร์เฟซล็อคเพราะมันไม่ต้องการให้ฉันใช้พลังงานของฉันในการปล่อยล็อค ฟังก์ชั่นนี้สามารถนำไปใช้ได้โดยการปล่อยล็อคในบล็อกในที่สุด
48) ล็อคการตรวจสอบสองครั้งในโหมดซิงเกิลตันคืออะไร?
คำถามนี้มักถูกถามในการสัมภาษณ์ Java แต่ผู้สัมภาษณ์มีความพึงพอใจเพียง 50% ที่ตอบคำถามนี้ ครึ่งหนึ่งของผู้คนไม่สามารถเขียนล็อคตรวจสอบสองครั้งและครึ่งหนึ่งของผู้คนไม่สามารถบอกได้ว่ามันเป็นอันตรายที่ซ่อนอยู่และวิธีการแก้ไข Java 1.5 จริงๆแล้วมันเป็นวิธีเก่า ๆ ในการสร้างซิงเกิลที่ปลอดภัยจากด้าย เมื่อมีการสร้างอินสแตนซ์ซิงเกิลครั้งแรกมันพยายามที่จะเพิ่มประสิทธิภาพการทำงานด้วยล็อคเดียว แต่เนื่องจากมันซับซ้อนเกินไปจึงล้มเหลวใน JDK1.4 และฉันก็ไม่ชอบเช่นกัน อย่างไรก็ตามแม้ว่าคุณจะไม่ชอบคุณก็ยังต้องเข้าใจเพราะมันมักจะถูกถาม คุณสามารถตรวจสอบว่าการล็อคการล็อคสองครั้งในบทความ Singleton Works สำหรับข้อมูลเพิ่มเติม
49) วิธีการสร้างซิงเกิลที่ปลอดภัยในกระทู้ใน Java?
นี่คือการติดตามคำถามข้างต้น หากคุณไม่ชอบล็อคตรวจสอบอีกครั้งและผู้สัมภาษณ์ถามเกี่ยวกับวิธีการอื่นในการสร้างคลาส Singleton คุณสามารถใช้การโหลดคลาส JVM และคุณสมบัติการเริ่มต้นตัวแปรแบบคงที่เพื่อสร้างอินสแตนซ์ซิงเกิลหรือใช้ประเภทการแจงนับเพื่อสร้างซิงเกิล ฉันชอบวิธีนี้ คุณสามารถตรวจสอบบทความนี้สำหรับข้อมูลเพิ่มเติม
50) เขียน 3 แนวทางปฏิบัติที่ดีที่สุดที่คุณติดตาม
ฉันชอบปัญหาประเภทนี้มากที่สุดและฉันเชื่อว่าคุณจะปฏิบัติตามแนวทางปฏิบัติที่ดีที่สุดบางอย่างเมื่อเขียนรหัสพร้อมกันเพื่อปรับปรุงประสิทธิภาพ นี่คือแนวทางปฏิบัติที่ดีที่สุดสามประการที่ฉันคิดว่าโปรแกรมเมอร์ Java ส่วนใหญ่ควรปฏิบัติตาม:
ตั้งชื่อเธรดของคุณที่มีความหมาย
ทำให้ง่ายต่อการค้นหาข้อบกพร่องหรือติดตามพวกเขา OrderProcessor, quoteprocessor หรือ TradeProcessor ชื่อนี้ดีกว่าเธรด -1 มาก Thread-2 และ Thread-3 ให้ชื่อเธรดที่เกี่ยวข้องกับงานที่ต้องการให้เสร็จสมบูรณ์ เฟรมเวิร์กที่สำคัญทั้งหมดและแม้แต่ JDKs ปฏิบัติตามแนวปฏิบัติที่ดีที่สุดนี้
หลีกเลี่ยงการล็อคและ จำกัด ขอบเขตของการซิงโครไนซ์
ล็อคมีราคาแพงและการสลับบริบทใช้เวลานานกว่า ลองใช้การซิงโครไนซ์และล็อคเพื่อลดพื้นที่วิกฤต ดังนั้นฉันชอบบล็อกการซิงโครไนซ์ผ่านวิธีการซิงโครไนซ์ซึ่งทำให้ฉันควบคุมการล็อคได้อย่างสมบูรณ์
ใช้คลาสการซิงโครไนซ์มากขึ้นและใช้การรอน้อยลงและแจ้งเตือน
อันดับแรก Countdownlatch, semaphore, cyclicbarrier และ exchanger คลาสซิงโครนัสทำให้การทำงานของการเข้ารหัสง่ายขึ้นในขณะที่มันยากที่จะควบคุมกระแสการควบคุมที่ซับซ้อนด้วยการรอและแจ้ง ประการที่สองคลาสเหล่านี้เขียนและดูแลโดยองค์กรที่ดีที่สุด พวกเขาจะยังคงได้รับการปรับให้เหมาะสมและปรับปรุงใน JDK ที่ตามมา การใช้เครื่องมือซิงโครไนซ์ระดับสูงกว่าโปรแกรมของคุณสามารถปรับให้เหมาะสมได้โดยไม่ต้องใช้ความพยายามใด ๆ
ใช้ชุดที่เกิดขึ้นพร้อมกันมากขึ้นและชุดที่ซิงโครไนซ์น้อยลง นี่เป็นแนวทางปฏิบัติที่ดีที่สุดที่ติดตามได้ง่าย ชุดที่เกิดขึ้นพร้อมกันนั้นสามารถปรับขนาดได้มากกว่าชุดที่ซิงโครไนซ์ดังนั้นการใช้ชุดพร้อมกันจะดีกว่าสำหรับการเขียนโปรแกรมพร้อมกัน หากคุณต้องการใช้ MAP ในครั้งต่อไปคุณควรคิดถึงการใช้ ConcurrentHashMap ก่อน บทความของฉันคอลเลกชัน Java พร้อมกันมีคำอธิบายโดยละเอียดมากขึ้น
51) วิธีการบังคับให้เริ่มต้นของเธรด?
ปัญหานี้เป็นเหมือนการบังคับคอลเลกชันขยะ Java ยังไม่มีวิธีที่จะทำ แม้ว่าคุณสามารถใช้ System.gc () เพื่อทำการรวบรวมขยะได้ แต่ก็ไม่รับประกันว่าจะประสบความสำเร็จ ไม่มีวิธีที่จะบังคับให้เธรดเริ่มต้นใน Java มันถูกควบคุมโดยตัวกำหนดเวลาเธรดและ Java ไม่ได้เผยแพร่ API ที่เกี่ยวข้อง
52) เฟรมเวิร์กเข้าร่วมส้อมคืออะไรใน Java?
fork join 框架是JDK7 中出现的一款高效的工具，Java 开发人员可以通过它充分利用现代服务器上的多处理器。它是专门为了那些可以递归划分成许多子模块设计的，目的是将所有可用的处理能力用来提升程序的性能。fork join 框架一个巨大的优势是它使用了工作窃取算法，可以完成更多任务的工作线程可以从其它线程中窃取任务来执行。你可以查看这篇文章获得更多信息。
53） Java 多线程中调用wait () 和sleep ()方法有什么不同？
Java 程序中wait 和sleep 都会造成某种形式的暂停，它们可以满足不同的需要。wait ()方法用于线程间通信，如果等待条件为真且其它线程被唤醒时它会释放锁，而sleep ()方法仅仅释放CPU 资源或者让当前线程停止执行一段时间，但不会释放锁。你可以查看这篇文章获得更多信息。