คู่มือการซิงโครไนซ์ใน Java

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

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

ดูหลักสูตรเทคโนโลยีฟรีของเราเพื่อให้เหนือกว่าคู่แข่ง

คู่มือนี้ อธิบายว่าการซิงโครไนซ์คืออะไรใน Java จะสำรวจแนวคิดของการซิงโครไนซ์โดยละเอียดพร้อมตัวอย่าง

เรียนรู้หลักสูตรการพัฒนาซอฟต์แวร์ออนไลน์จากมหาวิทยาลัยชั้นนำของโลก รับโปรแกรม Executive PG โปรแกรมประกาศนียบัตรขั้นสูง หรือโปรแกรมปริญญาโท เพื่อติดตามอาชีพของคุณอย่างรวดเร็ว

การซิงโครไนซ์ใน Java คืออะไร?

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

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

ตรวจสอบการรับรองขั้นสูงของ upGrad ใน DevOps

ไวยากรณ์สำหรับการเขียน Synchronized Block

ไวยากรณ์ทั่วไปสำหรับการเขียนบล็อกที่ซิงโครไนซ์ใน Java มีดังนี้:

ซิงโครไนซ์ ( lockObject )

{

// คำสั่งซิงโครไนซ์

}

สำรวจหลักสูตรวิศวกรรมซอฟต์แวร์ยอดนิยมของเรา

ในไวยากรณ์ข้างต้น lockObject หมายถึงอ็อบเจ็กต์ที่มีการล็อกที่เกี่ยวข้องกับองค์ประกอบที่ซิงโครไนซ์ นั่นนำเราไปสู่แนวคิดการล็อกใน Java

ตรวจสอบการรับรองขั้นสูงของ upGrad ใน Cyber ​​​​Security

ล็อคใน Java

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

ทักษะการพัฒนาซอฟต์แวร์ตามความต้องการ

Java Synchronized Method

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

นี่คือตัวอย่างของวิธีการซิงโครไนซ์ของ Java:

//ตัวอย่างวิธีการซิงโครไนซ์จาวา

ตารางเรียน{

ซิงโครไนซ์โมฆะ printTable(int n){//วิธีการซิงโครไนซ์

สำหรับ (int i=1;i<=5;i++){

System.out.println(n*i);

ลอง{

เธรด. สลีป (400);

}จับ(ข้อยกเว้น จ){System.out.println(e);}

}

}

}

คลาส MyThread1 ขยายเธรด{

ยาเม็ด;

MyThread1 (ตาราง t){

this.t=t;

}

โมฆะสาธารณะ () {

t.printTable(5);

}

}

คลาส MyThread2 ขยายเธรด{

ยาเม็ด;

MyThread2 (ตาราง t){

this.t=t;

}

โมฆะสาธารณะ () {

t.printTable(100);

}

}

คลาสสาธารณะ TestSynchronization2{

โมฆะคงที่สาธารณะหลัก (สตริง args[]){

ตาราง obj = ตารางใหม่ ();// เพียงหนึ่งวัตถุ

MyThread1 t1=ใหม่ MyThread1(obj);

MyThread2 t2=ใหม่ MyThread2(obj);

t1.start();

t2.start();

}

}

อ่านบทความยอดนิยมของเราเกี่ยวกับการพัฒนาซอฟต์แวร์

เอาท์พุท:

5

10

15

20

25

100

200

300

400

500

จะเกิดอะไรขึ้นหากไม่มีการซิงโครไนซ์

ตอนนี้ มาดูโปรแกรมก่อนหน้าที่ไม่มีการซิงโครไนซ์กัน (สังเกตว่าไม่มีคีย์เวิร์ดที่ซิงโครไนซ์)

ตารางเรียน{

โมฆะ printTable(int n){// วิธีไม่ซิงโครไนซ์

สำหรับ (int i=1;i<=5;i++){

System.out.println(n*i);

ลอง{

เธรด. สลีป (400);

}จับ(ข้อยกเว้น จ){System.out.println(e);}

}

}

}

คลาส MyThread1 ขยายเธรด{

ยาเม็ด;

MyThread1 (ตาราง t){

this.t=t;

}

โมฆะสาธารณะ () {

t.printTable(5);

}

}

คลาส MyThread2 ขยายเธรด{

ยาเม็ด;

MyThread2 (ตาราง t){

this.t=t;

}

โมฆะสาธารณะ () {

t.printTable(100);

}

}

คลาส Testการซิงโครไนซ์1{

โมฆะคงที่สาธารณะหลัก (สตริง args[]){

ตาราง obj = ตารางใหม่ ();// เพียงหนึ่งวัตถุ

MyThread1 t1=ใหม่ MyThread1(obj);

MyThread2 t2=ใหม่ MyThread2(obj);

t1.start();

t2.start();

}

}

เอาท์พุท:

5

100

10

200

15

300

20

400

25

500

อย่างที่คุณเห็น ผลลัพธ์ไม่สอดคล้องกันหากไม่มีการซิงโครไนซ์

ประเภทของการซิงโครไนซ์ใน Java

เพื่อตอบคำถาม ว่าการซิงโครไนซ์เธรดใน Java คืออะไร เรามีการซิงโครไนซ์สองประเภท: การซิงโครไนซ์เธรดและการซิงโครไนซ์กระบวนการ

มาทำความเข้าใจความหมายของแต่ละอย่างกัน

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

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

วิธีการซิงโครไนซ์ใน Java

โดยทั่วไปมีสี่วิธีในการซิงโครไนซ์ใน Java:

• วิธีการซิงโครไนซ์แบบคงที่
• วิธีการซิงโครไนซ์อินสแตนซ์
• บล็อกที่ซิงโครไนซ์ภายในวิธีการแบบคงที่
• บล็อกที่ซิงโครไนซ์ภายในเมธอดอินสแตนซ์

มาดูวิธีการซิงโครไนซ์ Java แต่ละวิธีโดยละเอียดกันดีกว่า

วิธีการซิงโครไนซ์แบบคงที่

ในที่นี้ เราใช้คีย์เวิร์ดที่ซิงโครไนซ์เพื่อทำเครื่องหมายเมธอดแบบสแตติกใน Java ต่อไปนี้คือตัวอย่างวิธีการซิงโครไนซ์แบบสแตติกของ Java:

MyStaticCounter แบบคงที่สาธารณะ {

จำนวน int คงที่ส่วนตัว = 0;

สาธารณะเพิ่มขึ้นโมฆะซิงโครไนซ์แบบคงที่ (ค่า int) {

นับ += ค่า;

}

}

วิธีการซิงโครไนซ์อินสแตนซ์

เมื่อใช้บล็อกที่ซิงโครไนซ์กับเมธอดของอินสแตนซ์ แต่ละอ็อบเจ็กต์จะมีวิธีการซิงโครไนซ์ แต่ละอ็อบเจ็กต์สามารถมีเธรดเดียวเท่านั้นที่สามารถดำเนินการภายในเมธอด หากมีหลายอ็อบเจ็กต์ เธรดเดียวสามารถดำเนินการสำหรับแต่ละอ็อบเจ็กต์ภายในบล็อกได้

MyCounter คลาสสาธารณะ {

จำนวน int ส่วนตัว = 0;

การเพิ่มโมฆะซิงโครไนซ์สาธารณะ (ค่า int) {

this.count += ค่า;

}

การลดโมฆะซิงโครไนซ์สาธารณะ (ค่า int) {

this.count -= ค่า;

}

}

บล็อกที่ซิงโครไนซ์ภายในวิธีการแบบคงที่

ด้านล่างนี้เป็นตัวอย่างที่เราใช้บล็อกที่ซิงโครไนซ์ภายในวิธีการแบบคงที่:

MyClass คลาสสาธารณะ {

พิมพ์โมฆะคงที่สาธารณะ (ข้อความสตริง) {

ซิงโครไนซ์ (MyClass.class) {

log.writeln(ข้อความ);

}

}

}

บล็อกที่ซิงโครไนซ์ภายในเมธอดอินสแตนซ์

แทนที่จะซิงโครไนซ์วิธีการทั้งหมด เราสามารถใช้การซิงโครไนซ์กับบล็อกเฉพาะภายในเมธอด ด้านล่างนี้เป็นตัวอย่างของบล็อกโค้ดที่ซิงโครไนซ์ภายในเมธอดที่ไม่ซิงโครไนซ์:

การเพิ่มโมฆะสาธารณะ (ค่า int) {

ซิงโครไนซ์ (นี้) {

this.count += ค่า;

}

}

ต้องการการซิงโครไนซ์ใน Java

ตอนนี้คุณรู้แล้ว ว่าการซิงโครไนซ์ใน Java คืออะไร คุณอาจสงสัยว่าทำไมเราถึงใช้มันตั้งแต่แรก

คีย์เวิร์ดที่ซิงโครไนซ์ของ Java จัดเตรียมฟังก์ชันที่จำเป็นสำหรับการเขียนโปรแกรมพร้อมกัน การซิงโครไนซ์ใน Java ช่วยได้ดังนี้:

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

บทสรุป

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

คุณต้องการเรียนรู้แนวคิดหลักใน Java หรือไม่? หลักสูตร upGrad Executive Post Graduate ในการพัฒนาซอฟต์แวร์ - ความเชี่ยวชาญใน หลักสูตร Full Stack Development เป็นโปรแกรมออนไลน์ 7 สัปดาห์สำหรับผู้เริ่มต้นที่ต้องการสำรวจอาชีพการพัฒนาซอฟต์แวร์ เข้าร่วมชั้นเรียนแบบสดและแบบโต้ตอบ เซสชั่นฝึกหัด และเนื้อหามากกว่า 35 ชั่วโมงที่ผู้นำในอุตสาหกรรมนำเสนอเพื่อรับใบรับรองการสำเร็จหลักสูตรจาก upGrad

ลงทะเบียนวันนี้ เพื่อรับ สิทธิประโยชน์ upGrad สุดพิเศษ จากการสนับสนุนนักศึกษาตลอด 24 ชั่วโมงทุกวันและการสร้างเครือข่ายในอุตสาหกรรม!