บทความนี้อธิบายถึงความแตกต่างระหว่างการซิงโครไนซ์ (ล็อควัตถุ) และการซิงโครไนซ์แบบคงที่ (ล็อคคลาส) ใน Java แบ่งปันสำหรับการอ้างอิงของคุณดังนี้:
ความแตกต่างระหว่างซิงโครไนซ์และซิงโครไนซ์แบบคงที่
โดยการวิเคราะห์การวิเคราะห์การใช้งานทั้งสองนี้เราสามารถเข้าใจแนวคิดของการล็อคใน Java หนึ่งคือการล็อคอินสแตนซ์ (ล็อคบนวัตถุอินสแตนซ์หากคลาสเป็นซิงเกิลตันแล้วล็อคก็มีแนวคิดของการล็อคทั่วโลก) และอีกอันคือล็อคทั่วโลก (ล็อคถูกกำหนดเป้าหมายในชั้นเรียน การล็อคอินสแตนซ์สอดคล้องกับคำหลักที่ซิงโครไนซ์ในขณะที่การล็อคคลาส (ล็อคทั่วโลก) สอดคล้องกับการซิงโครไนซ์แบบคงที่ (หรือล็อคบนคลาสหรือวัตถุคลาสโหลดของคลาส)
บทความต่อไปนี้ให้สรุปที่ดี:
1. ความแตกต่างระหว่างซิงโครไนซ์และซิงโครไนซ์แบบคงที่
ซิงโครไนซ์ล็อคอินสแตนซ์ปัจจุบัน (วัตถุปัจจุบัน) ของคลาสเพื่อป้องกันเธรดอื่น ๆ จากการเข้าถึงบล็อกที่ซิงโครไนซ์ทั้งหมดของอินสแตนซ์ของคลาสในเวลาเดียวกัน โปรดทราบว่านี่คือ "อินสแตนซ์ปัจจุบันของคลาส" ไม่มีข้อ จำกัด ดังกล่าวในสองกรณีที่แตกต่างกันของชั้นเรียน
จากนั้นการซิงโครไนซ์แบบคงที่เกิดขึ้นเพื่อควบคุมการเข้าถึงพร้อมกันของทุกกรณีของคลาสและการซิงโครไนซ์แบบคงที่ จำกัด อินสแตนซ์ทั้งหมดของคลาสในมัลติเธรดเพื่อเข้าถึงบล็อกรหัสที่สอดคล้องกับคลาสใน JVM ในเวลาเดียวกัน ในความเป็นจริงหากมีการซิงโครไนซ์ในเมธอดหรือบล็อกรหัสในคลาสหลังจากสร้างอินสแตนซ์ของคลาสอินสแตนซ์จะมีบล็อกการตรวจสอบเพื่อป้องกันเธรดจากการเข้าถึงบล็อกการป้องกันแบบซิงโครไนซ์พร้อมกันของอินสแตนซ์ การซิงโครไนซ์แบบคงที่เป็นบล็อกการตรวจสอบที่พบบ่อยสำหรับทุกกรณีของชั้นเรียน นี่คือความแตกต่างระหว่างสองคน กล่าวอีกนัยหนึ่งการซิงโครไนซ์นั้นเทียบเท่ากับสิ่งนี้ synchronized ในขณะที่การซิงโครไนซ์แบบคงที่เทียบเท่ากับบางสิ่งบางอย่าง synchronized (ที่อยู่ในภายหลัง)
นักเขียนชาวญี่ปุ่นคนหนึ่งของ Jie Chenghao "Java Multithreaded Design Pattern" มีคอลัมน์เช่นนี้:
Pulbic class something () {public synchronized void issynca () {} public synchronized void issyncb () {} public static synchronized csynca () {} โมฆะ cyncb () {}} {}} {}}ดังนั้นหากมีสองอินสแตนซ์ x และ y ของคลาสบางสิ่งบางอย่างกรณีเมื่อกลุ่มของวิธีการต่อไปนี้ถูกเข้าถึงพร้อมกันโดยหลายเธรด?
Axissynca () และ X.ISSYNCB ()
bxissynca () และ y.issynca ()
cxcsynca () และ y.csyncb ()
dxissynca () และบางสิ่งบางอย่าง csynca ()
ที่นี่เป็นที่ชัดเจนว่าสามารถตัดสินได้:
A ทั้งหมดคือการเข้าถึงโดเมนที่ซิงโครไนซ์ทั้งหมดไปยังอินสแตนซ์เดียวกัน (x) และดังนั้นจึงไม่สามารถเข้าถึงได้พร้อมกัน (โดเมนที่ซิงโครไนซ์ที่แตกต่างกันที่เข้าถึง X ใน multithreads ไม่สามารถเข้าถึงได้พร้อมกัน)
หาก X.ISSYNCA () เข้าถึงในหลายเธรดเนื่องจากยังคงเป็นอินสแตนซ์เดียวกันและล็อคด้วยวิธีเดียวกันมันไม่สามารถเข้าถึงได้ในหลายเธรดในเวลาเดียวกัน (โดเมนซิงโครไนซ์เดียวกันที่เข้าถึง X ใน multithreads ไม่สามารถเข้าถึงได้ในเวลาเดียวกัน)
B ใช้สำหรับอินสแตนซ์ที่แตกต่างกันดังนั้นจึงสามารถเข้าถึงได้ในเวลาเดียวกัน (ล็อควัตถุไม่มีข้อ จำกัด ล็อคสำหรับอินสแตนซ์วัตถุที่แตกต่างกัน)
C เนื่องจากมีการซิงโครไนซ์แบบคงที่อินสแตนซ์ที่แตกต่างกันจะยังคงถูก จำกัด ซึ่งเทียบเท่ากับบางสิ่งบางอย่าง issynca () และบางสิ่งบางอย่าง issyncb () ดังนั้นจึงไม่สามารถเข้าถึงได้ในเวลาเดียวกัน
แล้ว D แล้ว D?, คำตอบในหนังสือสามารถเข้าถึงได้พร้อมกัน เหตุผลสำหรับคำตอบคือซิงโครไนซ์คือวิธีการอินสแตนซ์และวิธีการคลาสซิงโครไนซ์นั้นแตกต่างจากการล็อค
การวิเคราะห์ส่วนบุคคลหมายความว่าการซิงโครไนซ์แบบซิงโครไนซ์และแบบคงที่เทียบเท่ากับแก๊งสองแก๊งซึ่งแต่ละตัวมีการควบคุมของตัวเองและไม่มีข้อ จำกัด ซึ่งกันและกันและสามารถเข้าถึงได้ในเวลาเดียวกัน
ตัวอย่างเช่น:
Public Class testsynchronized {โมฆะสาธารณะที่ซิงโครไนซ์ test1 () {int i = 5; ในขณะที่ (i--> 0) {system.out.println (thread.currentthread (). getName () + ":" + i); ลอง {thread.sleep (500); } catch (interruptedException IE) {}}} โมฆะแบบคงที่แบบคงที่สาธารณะ test2 () {int i = 5; ในขณะที่ (i--> 0) {system.out.println (thread.currentthread (). getName () + ":" + i); ลอง {thread.sleep (500); } catch (interruptedException IE) {}}} โมฆะคงที่สาธารณะหลัก (สตริง [] args) {final testsynchronized myt2 = ใหม่ testsynchronized (); เธรด test1 = เธรดใหม่ (ใหม่ runnable () {public void run () {myt2.test1 ();}}, "test1"); เธรด test2 = เธรดใหม่ (ใหม่ runnable () {public void run () {testsynchronized.test2 ();}}, "test2"); test1.start (); test2.start (); // testRunnable tr = new testRunnable (); // เธรด test3 = เธรดใหม่ (TR); // test3.start (); -test1: 4 test2: 4 test1: 3 test2: 3 test2: 2 test1: 2 test2: 1 test1: 1 test1: 0 test2: 0
รหัสด้านบนที่ซิงโครไนซ์ปรับเปลี่ยนวิธีการคงที่และวิธีการอินสแตนซ์ในเวลาเดียวกัน แต่ผลลัพธ์ที่รันจะดำเนินการสลับกันซึ่งพิสูจน์ให้เห็นว่าการล็อคคลาสและล็อควัตถุเป็นล็อคที่แตกต่างกันสองตัวควบคุมภูมิภาคที่แตกต่างกันและพวกเขาไม่รบกวนกันและกัน ในทำนองเดียวกันในขณะที่เธรดได้รับการล็อควัตถุพวกเขายังสามารถรับล็อคประเภทนี้ได้นั่นคือพวกเขาได้รับการล็อคสองตัวในเวลาเดียวกันซึ่งได้รับอนุญาต
สรุปแล้ว:
ตอบ: แบบคงที่แบบซิงโครไนซ์เป็นขอบเขตของคลาสที่แน่นอน ซิงโครไนซ์แบบคงที่ csync {} ป้องกันหลายอินสแตนซ์ในหลายเธรดจากการเข้าถึงวิธีการคงที่แบบซิงโครไนซ์ในคลาสนี้ในเวลาเดียวกัน มันทำงานกับทุกอินสแตนซ์วัตถุของคลาส
B: ซิงโครไนซ์เป็นขอบเขตของอินสแตนซ์ ซิงโครไนซ์ ISSYNC () {} ป้องกันไม่ให้อินสแตนซ์นี้เข้าถึงวิธีการซิงโครไนซ์ของคลาสนี้ในเวลาเดียวกัน
ในความเป็นจริงมันง่ายมากที่จะสรุป
2. ความแตกต่างระหว่างวิธีการซิงโครไนซ์และรหัสที่ซิงโครไนซ์อย่างรวดเร็ว
ไม่มีความแตกต่างระหว่างวิธีการซิงโครไนซ์ () {} และซิงโครไนซ์ (สิ่งนี้) {} แต่วิธีการซิงโครไนซ์ () {} สะดวกสำหรับการอ่านความเข้าใจในขณะที่ซิงโครไนซ์
การเปรียบเทียบประสิทธิภาพระหว่างสองวิธี:
1. ซิงโครไนซ์บล็อกรหัสมีดังนี้:
นำเข้า java.util.concurrent.countdownlatch; นำเข้า java.util.concurrent.executorservice; นำเข้า java.util.concurrent.executors; คลาสสาธารณะ testsynchronized { / ** * @param args * / โมฆะคงที่สาธารณะหลัก (สตริง [] args) {executorservice service = executors.newcachedthreadpool (); Countdownlatch cdorder = New Countdownlatch (1); countdownlatch สุดท้าย cdanswer = new countdownlatch (3); synchonizedclass สุดท้าย sc = new synchonizedclass (); สำหรับ (int i = 0; i <3; i ++) {runnable runnable = new runnable () {public void run () {ลอง {cdorder.await (); Sc.Start (); cdanswer.countdown (); } catch (exception e) {e.printstacktrace (); - Service.execute (Runnable); } ลอง {thread.sleep ((ยาว) (math.random ()*10,000)); System.out.println ("เธรด" + thread.currentthread (). getName () + "เผยแพร่คำสั่งการดำเนินการ"); cdorder.countdown (); Long Begintime = System.currentTimeMillis (); System.out.println ("เธรด" + thread.currentthread (). getName () + "คำสั่งถูกส่งแล้วรอผลลัพธ์"); cdanswer.await (); System.out.println ("เธรด" + thread.currentthread (). getName ()) + "ได้รับผลการตอบกลับทั้งหมดเวลาที่ใช้คือ:" + (System.currentTimeMillis ()-Begintime)); } catch (exception e) {e.printstacktrace (); } service.shutdown (); }} คลาส SynchonizedClass {public void start () พ่น InterruptedException {thread.sleep (100); // ดำเนินการตรรกะอื่น ๆ เพื่อใช้เวลาซิงโครไนซ์เวลา (นี้) {system.out.println ("ฉันวิ่งด้วย 10 ms"); - ผลการดำเนินการมีดังนี้:
เธรดหลักจะเปิดตัวคำสั่งการดำเนินการเธรดหลักได้ส่งคำสั่งรอผลลัพธ์ที่ฉันวิ่งและใช้ 10 มิลลิวินาที
ฉันทำงานโดยใช้ 10 ms
ฉันทำงานโดยใช้ 10 ms
เธรดหลักได้รับผลการตอบกลับทั้งหมดและเวลาที่ใช้คือ: 110
วิธีการซิงโครไนซ์รหัสมีดังนี้:
นำเข้า java.util.concurrent.countdownlatch; นำเข้า java.util.concurrent.executorservice; นำเข้า java.util.concurrent.executors; คลาสสาธารณะ testsynchronized { / ** * @param args * / โมฆะคงที่สาธารณะหลัก (สตริง [] args) {executorservice service = executors.newcachedthreadpool (); Countdownlatch cdorder = New Countdownlatch (1); countdownlatch สุดท้าย cdanswer = new countdownlatch (3); synchonizedclass สุดท้าย sc = new synchonizedclass (); สำหรับ (int i = 0; i <3; i ++) {runnable runnable = new runnable () {public void run () {ลอง {cdorder.await (); Sc.Start (); cdanswer.countdown (); } catch (exception e) {e.printstacktrace (); - Service.execute (Runnable); } ลอง {thread.sleep ((ยาว) (math.random ()*10,000)); System.out.println ("เธรด" + thread.currentthread (). getName () + "เผยแพร่คำสั่งการดำเนินการ"); cdorder.countdown (); Long Begintime = System.currentTimeMillis (); System.out.println ("เธรด" + thread.currentthread (). getName () + "คำสั่งถูกส่งแล้วรอผลลัพธ์"); cdanswer.await (); System.out.println ("เธรด" + thread.currentthread (). getName ()) + "ได้รับผลการตอบกลับทั้งหมดเวลาที่ใช้คือ:" + (System.currentTimeMillis ()-Begintime)); } catch (exception e) {e.printstacktrace (); } service.shutdown (); }} คลาส SynchonizedClass {public synchronized void start () พ่น InterruptedException {thread.sleep (100); // ดำเนินการตามเวลาตรรกะอื่น ๆ // ซิงโครไนซ์ (นี่) {system.out.println ("ฉันใช้ 10 ms"); -ผลการดำเนินการมีดังนี้:
เธรดหลักจะเปิดตัวคำสั่งการดำเนินการเธรดหลักได้ส่งคำสั่งรอผลลัพธ์ที่ฉันวิ่งและใช้ 10 มิลลิวินาที
ฉันทำงานโดยใช้ 10 ms
ฉันทำงานโดยใช้ 10 ms
เธรดหลักได้รับผลการตอบกลับทั้งหมดและเวลาที่ใช้คือ: 332
ความแตกต่างระหว่างทั้งสองคือ: 222ms
การเปรียบเทียบแสดงให้เห็นว่าบล็อกรหัสแบบซิงโครนัสมีประสิทธิภาพมากกว่าวิธีการซิงโครไนซ์
หน่วยความจำเพิ่มเติม:
1. คำหลักที่ซิงโครไนซ์มีสองขอบเขต:
1) อยู่ในอินสแตนซ์ของวัตถุ amethod ที่ซิงโครไนซ์ () {} สามารถป้องกันหลายเธรดจากการเข้าถึงวิธีการซิงโครไนซ์ของวัตถุนี้ในเวลาเดียวกัน (ถ้าวัตถุมีวิธีการซิงโครไนซ์หลายวิธีตราบใดที่เธรดหนึ่งเข้าถึงหนึ่งในวิธีการซิงโครไนซ์เธรดอื่น ๆ ไม่สามารถเข้าถึงวิธีการซิงโครไนซ์ใด ๆ ในวัตถุในเวลาเดียวกัน) ในเวลานี้วิธีการซิงโครไนซ์ของอินสแตนซ์วัตถุที่แตกต่างกันไม่หยุดชะงัก กล่าวคือเธรดอื่น ๆ ยังสามารถเข้าถึงวิธีการซิงโครไนซ์ในอินสแตนซ์ของวัตถุอื่นของคลาสเดียวกันในเวลาเดียวกัน
2) มันเป็นขอบเขตของคลาสที่แน่นอน ซิงโครไนซ์แบบคงที่ astaticMethod {} ป้องกันวัตถุอินสแตนซ์ที่แตกต่างกัน (หรือวัตถุอินสแตนซ์เดียวกัน) ในหลายเธรดจากการเข้าถึงวิธีคงที่ซิงโครไนซ์ในคลาสนี้ในเวลาเดียวกัน มันทำงานกับทุกอินสแตนซ์วัตถุของคลาส
2. นอกเหนือจากการใช้คำหลักที่ซิงโครไนซ์ก่อนวิธีการแล้วคำหลักที่ซิงโครไนซ์ยังสามารถใช้ในบล็อกในวิธีการซึ่งบ่งชี้ว่าการเข้าถึงแบบพิเศษร่วมกันเท่านั้นที่ดำเนินการบนทรัพยากรของบล็อกนี้ การใช้งานคือ: ซิงโครไนซ์ (นี่) {/*block*/} (หรือซิงโครไนซ์ (obj) {/*block*/}) และขอบเขตของมันคือวัตถุปัจจุบัน;
3. คำหลักที่ซิงโครไนซ์ไม่สามารถสืบทอดได้ กล่าวคือวิธีการของคลาสพื้นฐานที่ซิงโครไนซ์ f () {} ไม่ได้ซิงโครไนซ์โดยอัตโนมัติ f () {} ในคลาสที่สืบทอด แต่กลายเป็น f () {} คลาสการสืบทอดต้องการให้คุณระบุอย่างชัดเจนว่าหนึ่งในวิธีการของมันถูกซิงโครไนซ์;
ความเข้าใจบางอย่างเกี่ยวกับการซิงโครไนซ์ (นี้) (อธิบายการล็อควัตถุให้ดีให้ความสนใจกับคำหลักนี้ในนั้น)
1. เมื่อสองเธรดพร้อมกันเข้าถึงบล็อกรหัสที่ซิงโครไนซ์นี้ (นี้) ซิงโครไนซ์ในวัตถุวัตถุเดียวกันสามารถดำเนินการได้เพียงหนึ่งเธรดภายในหนึ่งครั้ง เธรดอื่นจะต้องรอให้เธรดปัจจุบันเรียกใช้งานบล็อกรหัสนี้ก่อนที่จะสามารถเรียกใช้งานบล็อกรหัส
2. อย่างไรก็ตามเมื่อเธรดหนึ่งเข้าถึงบล็อกรหัสการซิงโครไนซ์ซิงโครไนซ์ (นี้) ของวัตถุเธรดอื่นยังสามารถเข้าถึงบล็อกรหัสซิงโครไนซ์ที่ไม่ซิงโครไนซ์ (นี่) ในวัตถุนั้น
3. เป็นสิ่งสำคัญอย่างยิ่งที่เมื่อเธรดเข้าถึงบล็อกรหัสซิงโครไนซ์ซิงโครไนซ์ (นี้) ของวัตถุเธรดอื่น ๆ จะบล็อกการเข้าถึงไปยังบล็อกรหัสซิงโครไนซ์อื่น ๆ ทั้งหมดที่ซิงโครไนซ์ (นี้) ในวัตถุ
4. ตัวอย่างที่สามยังใช้กับบล็อกรหัสซิงโครนัสอื่น ๆ นั่นคือเมื่อเธรดเข้าถึงบล็อกรหัสซิงโครไนซ์ซิงโครไนซ์ (นี้) ของวัตถุจะได้รับการล็อควัตถุของวัตถุนี้ เป็นผลให้เธรดอื่น ๆ เข้าถึงส่วนรหัสแบบซิงโครนัสทั้งหมดของวัตถุวัตถุถูกบล็อกชั่วคราว
5. กฎข้างต้นใช้กับล็อควัตถุอื่น ๆ
เพิ่มโค้ดเพื่ออำนวยความสะดวกในการทดสอบคำหลักที่ซิงโครไนซ์ (การปรับเปลี่ยนอย่างง่าย)
Public Class testsynchronized {public void test1 () {ซิงโครไนซ์ (นี่) {int i = 5; ในขณะที่ (i--> 0) {system.out.println (thread.currentthread (). getName () + ":" + i); ลอง {thread.sleep (500); } catch (interruptedException IE) {}}}} โมฆะที่ซิงโครไนซ์สาธารณะ test2 () {int i = 5; ในขณะที่ (i--> 0) {system.out.println (thread.currentthread (). getName () + ":" + i); ลอง {thread.sleep (500); } catch (interruptedException IE) {}}} โมฆะที่ซิงโครไนซ์สาธารณะ test3 () {int i = 5; ในขณะที่ (i--> 0) {system.out.println (thread.currentthread (). getName () + ":" + i); ลอง {thread.sleep (500); } catch (interruptedException IE) {}}} โมฆะคงที่สาธารณะหลัก (สตริง [] args) {final testsynchronized myt2 = ใหม่ testsynchronized (); testsynchronized myt3 = testsynchronized ใหม่ (); เธรด test1 = เธรดใหม่ (ใหม่ runnable () {public void run () {myt2.test2 ();}}, "test1"); เธรด test2 = เธรดใหม่ (ใหม่ runnable () {public void run () {myt2.test3 ();}}, "test3"); test1.start () ;; test2.start (); - ผลการทำงาน:
Test1: 4Test1: 3Test1: 2Test1: 1Test1: 0Test3: 4Test3: 3Test3: 2Test3: 1Test3: 0
ด้านล่างเรามุ่งเน้นไปที่การใช้ sychronized ใน Java ซึ่งเป็นพิเศษ: วิธีการซิงโครไนซ์และคำหลักที่ซิงโครไนซ์บล็อกซิงโครไนซ์ซึ่งรวมถึงการใช้งานสองวิธี: วิธีการซิงโครไนซ์และบล็อกซิงโครไนซ์
1. วิธีการซิงโครไนซ์: ประกาศวิธีการซิงโครไนซ์โดยการเพิ่มคำหลักที่ซิงโครไนซ์ลงในการประกาศวิธีการ ชอบ:
Public Synchronized Void AccessVal (int newVal);
วิธีการที่ซิงโครไนซ์ควบคุมการเข้าถึงตัวแปรสมาชิกคลาส: แต่ละอินสแตนซ์คลาสสอดคล้องกับการล็อคและแต่ละวิธีที่ซิงโครไนซ์จะต้องได้รับการล็อคของอินสแตนซ์คลาสที่เรียกวิธีการก่อนที่จะสามารถดำเนินการได้ มิฉะนั้นเธรดที่เป็นของมันถูกบล็อก เมื่อใช้วิธีการแล้วมันจะครอบครองล็อคเท่านั้น ล็อคจะไม่ถูกปล่อยออกมาจนกว่าจะกลับมาจากวิธีการ เธรดที่ถูกบล็อกสามารถรับการล็อคและป้อนสถานะการทำงานได้อีกครั้ง กลไกนี้ทำให้มั่นใจได้ว่าในเวลาเดียวกันสำหรับแต่ละชั้นเรียนส่วนใหญ่หนึ่งฟังก์ชั่นสมาชิกทั้งหมดที่ประกาศว่าซิงโครไนซ์อยู่ในสถานะปฏิบัติการ (เพราะส่วนใหญ่หนึ่งสามารถรับล็อคที่สอดคล้องกับอินสแตนซ์ของคลาส) ดังนั้นจึงหลีกเลี่ยงการเข้าถึงตัวแปรสมาชิกชั้นเรียน (ตราบใดที่วิธีการทั้งหมดที่เป็นไปได้
ใน Java ไม่เพียง แต่อินสแตนซ์คลาสแต่ละคลาสจะสอดคล้องกับการล็อคดังนั้นเราจึงสามารถประกาศฟังก์ชั่นสมาชิกแบบคงที่ของชั้นเรียนที่ซิงโครไนซ์แบบคงที่เพื่อควบคุมการเข้าถึงตัวแปรสมาชิกคงที่ของชั้นเรียน
ข้อเสียของวิธีการซิงโครไนซ์: การประกาศวิธีการขนาดใหญ่เนื่องจากการซิงโครไนซ์จะส่งผลกระทบอย่างมากต่อประสิทธิภาพ โดยทั่วไปหากวิธีการของคลาสเธรด Run () ถูกประกาศว่าเป็นซิงโครไนซ์เนื่องจากมันทำงานตลอดชีวิตของเธรดมันจะทำให้มันไม่ประสบความสำเร็จในวิธีการซิงโครไนซ์ใด ๆ ของคลาสนี้ แน่นอนว่าเราสามารถแก้ปัญหานี้ได้โดยใส่รหัสที่เข้าถึงตัวแปรสมาชิกชั้นเรียนเป็นวิธีพิเศษประกาศว่ามันเป็นซิงโครไนซ์และเรียกมันในวิธีหลัก แต่ Java ให้วิธีแก้ปัญหาที่ดีกว่านั่นคือบล็อกที่ซิงโครไนซ์
2. บล็อกซิงโครไนซ์: ประกาศบล็อกที่ซิงโครไนซ์ผ่านคำหลักที่ซิงโครไนซ์ ไวยากรณ์มีดังนี้:
ซิงโครไนซ์ (syncobject) {// รหัสที่อนุญาตให้ควบคุมการเข้าถึง} บล็อกที่ซิงโครไนซ์เป็นบล็อกโค้ดที่รหัสจะต้องได้รับการล็อคของวัตถุ syncobject (ดังที่ได้กล่าวไว้ก่อนหน้านี้อาจเป็นอินสแตนซ์คลาสหรือคลาส) ก่อนที่จะสามารถดำเนินการได้ กลไกเฉพาะนั้นเหมือนกับที่อธิบายไว้ข้างต้น เนื่องจากสามารถกำหนดเป้าหมายได้ที่บล็อกรหัสใด ๆ และวัตถุที่ล็อคสามารถระบุได้ตลอดเวลาจึงมีความยืดหยุ่นมากขึ้น
สังเกต:
เมื่อใช้คำหลักที่ซิงโครไนซ์คุณควรหลีกเลี่ยงการใช้วิธีการนอนหลับหรือผลผลิตในวิธีการซิงโครไนซ์หรือบล็อกที่ซิงโครไนซ์ให้มากที่สุดเท่าที่จะเป็นไปได้ ไม่เพียง แต่ส่งผลกระทบต่อประสิทธิภาพอย่างจริงจัง แต่ยังไม่สมเหตุสมผล
ในทำนองเดียวกันมันไม่สมเหตุสมผลที่จะเรียกวิธีการ YEILD ในบล็อกโปรแกรมแบบซิงโครนัสเพื่อให้ทรัพยากร CPU เนื่องจากคุณครอบครองล็อคและเธรด mutex อื่น ๆ ยังไม่สามารถเข้าถึงบล็อกโปรแกรมซิงโครนัสได้ แน่นอนเธรดที่ไม่เกี่ยวข้องกับบล็อกโปรแกรมแบบซิงโครนัสสามารถรับเวลาดำเนินการได้มากขึ้น
ข้างต้นเป็นเนื้อหาทั้งหมดของบทความนี้ ฉันหวังว่ามันจะเป็นประโยชน์ต่อการเรียนรู้ของทุกคนและฉันหวังว่าทุกคนจะสนับสนุน wulin.com มากขึ้น