Java multithreading - บล็อกซิงโครนัส
บล็อก Java Synchronized ใช้เพื่อทำเครื่องหมายวิธีการหรือบล็อกรหัสที่ซิงโครไนซ์ บล็อกการซิงโครไนซ์ Java ใช้เพื่อหลีกเลี่ยงการแข่งขัน บทความนี้แนะนำเนื้อหาต่อไปนี้:
คำหลักที่ซิงโครไนซ์ Java (ซิงโครไนซ์)
บล็อกที่ซิงโครไนซ์ใน Java ถูกทำเครื่องหมายไว้ บล็อกการซิงโครไนซ์ถูกซิงโครไนซ์บนวัตถุใน Java บล็อกการซิงโครไนซ์ทั้งหมดที่ซิงโครไนซ์บนวัตถุสามารถป้อนได้เพียงหนึ่งเธรดและดำเนินการในเวลาเดียวกัน เธรดอื่น ๆ ทั้งหมดที่รอการเข้าสู่บล็อกการซิงโครไนซ์จะถูกบล็อกจนกว่าเธรดในบล็อกการซิงโครไนซ์จะถูกดำเนินการทางออก
มีสี่บล็อกการซิงโครไนซ์ที่แตกต่างกัน:
บล็อกการซิงโครไนซ์ข้างต้นทั้งหมดจะถูกซิงโครไนซ์บนวัตถุที่แตกต่างกัน การซิงโครไนซ์บล็อกใดที่จำเป็นจริงขึ้นอยู่กับสถานการณ์เฉพาะ
การซิงโครไนซ์วิธีการอินสแตนซ์
นี่คือวิธีการที่ซิงโครไนซ์:
โมฆะที่ซิงโครไนซ์สาธารณะเพิ่ม (ค่า int) {this.count += ค่า; -
การซิงโครไนซ์วิธีการ
การซิงโครไนซ์วิธีการแบบสแตติกนั้นเหมือนกับวิธีการซิงโครไนซ์วิธีการอินสแตนซ์และคำหลักที่ซิงโครไนซ์ก็ใช้ การซิงโครไนซ์วิธีการแบบคงที่ของ Java มีดังนี้:
โมฆะแบบซิงโครไนซ์แบบคงที่สาธารณะเพิ่ม (ค่า int) {count += ค่า; -ในทำนองเดียวกันคำหลักที่ซิงโครไนซ์ที่นี่จะบอก Java ว่าวิธีนี้ถูกซิงโครไนซ์
การซิงโครไนซ์ของวิธีการคงที่หมายถึงการซิงโครไนซ์บนวัตถุคลาสที่มีวิธีการอยู่ เนื่องจากคลาสสามารถสอดคล้องกับวัตถุคลาสหนึ่งในเครื่องเสมือน Java จึงอนุญาตให้ใช้วิธีการซิงโครไนซ์แบบคงที่เพียงหนึ่งเธรดในคลาสเดียวกัน
สำหรับวิธีการซิงโครไนซ์แบบคงที่ในคลาสที่แตกต่างกันเธรดสามารถเรียกใช้วิธีการซิงโครไนซ์แบบคงที่ในแต่ละคลาสโดยไม่ต้องรอ โดยไม่คำนึงถึงวิธีการซิงโครไนซ์แบบคงที่ในชั้นเรียนที่เรียกว่าคลาสสามารถดำเนินการได้เพียงหนึ่งเธรดในเวลาเดียวกัน
บล็อกแบบซิงโครนัสในวิธีการอินสแตนซ์
บางครั้งคุณไม่จำเป็นต้องซิงค์วิธีทั้งหมด แต่แทนที่จะซิงโครไนซ์บางส่วนของวิธีการ Java สามารถซิงโครไนซ์ส่วนหนึ่งของวิธีการ
ตัวอย่างของบล็อกการซิงโครไนซ์ในวิธี Java แบบอะซิงโครนัสแสดงอยู่ด้านล่าง:
โมฆะสาธารณะเพิ่ม (ค่า int) {ซิงโครไนซ์ (นี่) {this.count += ค่า; -ตัวอย่างใช้ตัวสร้างบล็อกแบบซิงโครนัส Java เพื่อทำเครื่องหมายชิ้นส่วนของรหัสที่ซิงโครไนซ์ รหัสนี้เหมือนกับวิธีการซิงโครไนซ์เมื่อดำเนินการ
โปรดทราบว่าตัวสร้างบล็อก Java Synchronous จะแนบวัตถุในวงเล็บ ในตัวอย่างข้างต้นใช้ "สิ่งนี้" นั่นคืออินสแตนซ์ของตัวเองที่เรียกวิธีการเพิ่ม วัตถุที่อยู่ในวงเล็บในตัวสร้างการซิงโครไนซ์เรียกว่าวัตถุมอนิเตอร์ รหัสด้านบนใช้การซิงโครไนซ์วัตถุตรวจสอบและวิธีการแบบซิงโครนัสใช้อินสแตนซ์ของวิธีการเรียกตัวเองเป็นวัตถุการตรวจสอบ
มีเพียงเธรดเดียวเท่านั้นที่สามารถดำเนินการในวิธี Java ที่ซิงโครไนซ์กับวัตถุตรวจสอบเดียวกันในแต่ละครั้ง
ตัวอย่างสองตัวอย่างต่อไปนี้ซิงโครไนซ์วัตถุอินสแตนซ์ที่พวกเขาเรียกดังนั้นพวกเขาจึงเทียบเท่ากับเอฟเฟกต์การดำเนินการแบบซิงโครไนซ์
คลาสสาธารณะ MyClass {โมฆะที่ซิงโครไนซ์สาธารณะ (สตริง MSG1, สตริง MSG2) {log.writeLn (MSG1); log.writeln (msg2); } โมฆะสาธารณะ log2 (สตริง msg1, สตริง msg2) {ซิงโครไนซ์ (นี่) {log.writeLn (msg1); log.writeln (msg2); -ในตัวอย่างข้างต้นสามารถดำเนินการเธรดได้เพียงหนึ่งเธรดในสองบล็อกการซิงโครไนซ์ในแต่ละครั้ง
หากบล็อกซิงโครไนซ์ที่สองไม่ได้ซิงโครไนซ์บนวัตถุอินสแตนซ์นี้ทั้งสองวิธีสามารถดำเนินการพร้อมกันได้โดยเธรด
บล็อกแบบซิงโครนัสในวิธีการคงที่
คล้ายกับข้างต้นสิ่งต่อไปนี้เป็นตัวอย่างของการซิงโครไนซ์สองวิธีแบบคงที่ วิธีการเหล่านี้ถูกซิงโครไนซ์บนวัตถุคลาสซึ่งเป็นวิธีการ
คลาสสาธารณะ MyClass {โมฆะแบบสแตติกแบบคงที่สาธารณะ log1 (สตริง MSG1, สตริง MSG2) {log.writeLn (MSG1); log.writeln (msg2); } โมฆะคงที่สาธารณะ log2 (สตริง msg1, สตริง msg2) {ซิงโครไนซ์ (myclass.class) {log.writeln (msg1); log.writeln (msg2); -สองวิธีนี้ไม่อนุญาตให้เข้าถึงโดยเธรดในเวลาเดียวกัน
หากบล็อกซิงโครไนซ์ที่สองไม่ได้ซิงโครไนซ์บนวัตถุ myclass.class จากนั้นสองวิธีนี้สามารถเข้าถึงได้โดยเธรดในเวลาเดียวกัน
อินสแตนซ์การซิงโครไนซ์ Java
ในตัวอย่างต่อไปนี้มีเธรดสองตัวเริ่มต้นทั้งการเรียกใช้วิธีเพิ่มของอินสแตนซ์เดียวกันของคลาสเคาน์เตอร์ เนื่องจากการซิงโครไนซ์อยู่ในอินสแตนซ์ที่เป็นของวิธีการมีเพียงเธรดเดียวเท่านั้นที่สามารถเข้าถึงวิธีการในเวลาเดียวกัน
เคาน์เตอร์ระดับสาธารณะ {long count = 0; โมฆะที่ซิงโครไนซ์สาธารณะเพิ่ม (ค่ายาว) {this.count += ค่า; }} counterThread คลาสสาธารณะขยายเธรด {ตัวนับที่ป้องกัน = null; Public CounterThread (ตัวนับตัวนับ) {this.count = counter; } โมฆะสาธารณะเรียกใช้ () {สำหรับ (int i = 0; i <10; i ++) {counter.add (i); }}} ตัวอย่างคลาสสาธารณะ {โมฆะสาธารณะคงที่หลัก (สตริง [] args) {ตัวนับตัวนับ = ตัวนับใหม่ (); เธรดเธรด = ใหม่ counterThread (ตัวนับ); Thread Threadb = ใหม่ counterThread (ตัวนับ); threada.start (); Threadb.start (); -สองเธรดถูกสร้างขึ้น ตัวสร้างของพวกเขาหมายถึงอินสแตนซ์ตัวนับเดียวกัน วิธี counter.add ถูกซิงโครไนซ์ในอินสแตนซ์เนื่องจากวิธีการเพิ่มเป็นวิธีการอินสแตนซ์และถูกทำเครื่องหมายด้วยคำหลักที่ซิงโครไนซ์ ดังนั้นจึงอนุญาตให้เรียกใช้วิธีเดียวได้ในแต่ละครั้ง เธรดอื่นจะต้องรอจนกว่าเธรดแรกจะออกจากวิธีการเพิ่ม () ก่อนที่จะดำเนินการต่อเพื่อดำเนินการวิธีการ
หากสองเธรดอ้างถึงอินสแตนซ์ตัวนับที่แตกต่างกันสองอินสแตนซ์พวกเขาสามารถเรียกวิธีการเพิ่ม () ในเวลาเดียวกัน วิธีการเหล่านี้เรียกวัตถุที่แตกต่างกันดังนั้นวิธีการเหล่านี้จะถูกซิงโครไนซ์กับวัตถุต่าง ๆ วิธีการเหล่านี้จะไม่ถูกบล็อก ดังที่แสดงในตัวอย่างต่อไปนี้:
ตัวอย่างชั้นเรียนสาธารณะ {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {countera counter = new counter (); เคาน์เตอร์เคาน์เตอร์ = ตัวนับใหม่ (); เธรดเธรด = ใหม่ counterthread (countera); เธรดเธรด b = ใหม่ counterThread (counterb); threada.start (); Threadb.start (); -โปรดทราบว่าเธรดทั้งสองนี้ Threada และ Threadb ไม่ได้อ้างถึงอินสแตนซ์ตัวนับเดียวกันอีกต่อไป วิธีการเพิ่มของ countera และ counterb ถูกซิงโครไนซ์กับวัตถุที่พวกเขาอยู่ การเรียกวิธีการเพิ่มของเคาน์เตอร์จะไม่บล็อกการโทรไปยังวิธีเพิ่มของ CounterB
ข้างต้นเป็นคำอธิบายของความรู้เกี่ยวกับบล็อกการซิงโครไนซ์แบบหลายเธรด Java เราจะยังคงเพิ่มข้อมูลที่เกี่ยวข้องในอนาคต ขอบคุณสำหรับการสนับสนุนเว็บไซต์นี้!