Java Synchronized Block สำหรับ. class

รหัสจาวาหมายถึงอะไร? จะได้รับการล็อควัตถุทั้งหมดของMyClass?

synchronized(MyClass.class) {
   //is all objects of MyClass are thread-safe now ??
}

และโค้ดด้านบนแตกต่างจากโค้ดนี้อย่างไร:

synchronized(this) {
   //is all objects of MyClass are thread-safe now ??
}

ตัวอย่างข้อมูล synchronized(X.class)ใช้อินสแตนซ์คลาสเป็นมอนิเตอร์ เนื่องจากมีอินสแตนซ์คลาสเดียวเท่านั้น (อ็อบเจ็กต์ที่แสดงข้อมูลเมตาของคลาสที่รันไทม์) หนึ่งเธรดจึงสามารถอยู่ในบล็อกนี้ได้

ด้วยsynchronized(this)บล็อกจะถูกปกป้องโดยอินสแตนซ์ สำหรับทุกอินสแตนซ์จะมีเพียงเธรดเดียวเท่านั้นที่เข้าสู่บล็อก

synchronized(X.class)ใช้เพื่อให้แน่ใจว่ามีเธรดเดียวในบล็อก synchronized(this)ตรวจสอบให้แน่ใจว่ามีหนึ่งเธรดต่ออินสแตนซ์ หากสิ่งนี้ทำให้รหัสจริงในบล็อกเธรดปลอดภัยขึ้นอยู่กับการนำไปใช้งาน ถ้าเปลี่ยนสถานะเฉพาะของอินสแตนซ์synchronized(this)ก็เพียงพอแล้ว

หากต้องการเพิ่มคำตอบอื่น ๆ :

static void myMethod() {
  synchronized(MyClass.class) {
    //code
  }
}

เทียบเท่ากับ

static synchronized void myMethod() {
  //code
}

และ

void myMethod() {
  synchronized(this) {
    //code
  }
}

เทียบเท่ากับ

synchronized void myMethod() {
  //code
}

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

อย่างที่สองจะได้รับการล็อคอินสแตนซ์ปัจจุบันเท่านั้น

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

ใช่มันจะ (บนบล็อก / ฟังก์ชันที่ซิงโครไนซ์ใด ๆ )

ฉันสงสัยเกี่ยวกับคำถามนี้มาสองสามวันแล้วสำหรับตัวเอง (จริงๆแล้วใน kotlin) ในที่สุดฉันก็พบคำอธิบายที่ดีและต้องการแบ่งปัน:

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

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

นอกจากนี้ยังสังเกตเห็นว่าทำไม. class . เป็นเพียงเพราะ.classเทียบเท่ากับตัวแปรคงที่ของคลาสที่คล้ายกับ:

private final static Object lock = new Object();

โดยที่ชื่อตัวแปรล็อคคือคลาสและประเภทคือคลาส <T>

อ่านเพิ่มเติม: https://howtodoinjava.com/java/multi-threading/object-vs-class-level-locking/