เหตุใดชั้นนี้จึงไม่ปลอดภัย

class ThreadSafeClass extends Thread
{
     private static int count = 0;

     public synchronized static void increment()
     {
         count++;
     }

     public synchronized void decrement()
     {
         count--;
     }
}

ใครช่วยอธิบายได้ไหมว่าทำไมชั้นเรียนข้างบนจึงไม่ปลอดภัย

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

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

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

ใครช่วยอธิบายได้ไหมว่าทำไมชั้นเรียนข้างบนจึงไม่ปลอดภัย

• increment เป็นแบบคงที่การซิงโครไนซ์จะทำในคลาสเอง
• decrementการไม่คงที่การซิงโครไนซ์จะทำในอินสแตนซ์ของอ็อบเจ็กต์ แต่ไม่ได้รักษาความปลอดภัยอะไรcountเลย

ฉันต้องการเพิ่มสิ่งนั้นเพื่อประกาศตัวนับเธรดที่ปลอดภัยฉันเชื่อว่าวิธีที่ง่ายที่สุดคือการใช้AtomicIntegerแทน int ดั้งเดิม

ให้ฉันเปลี่ยนเส้นทางคุณไปยังjava.util.concurrent.atomicข้อมูลแพ็คเกจ

คำตอบของคนอื่นอธิบายเหตุผลได้ดีทีเดียว ฉันเพิ่งเพิ่มบางสิ่งเพื่อสรุปsynchronized:

public class A {
    public synchronized void fun1() {}

    public synchronized void fun2() {}

    public void fun3() {}

    public static synchronized void fun4() {}

    public static void fun5() {}
}

A a1 = new A();

synchronizedเปิดfun1และfun2ซิงโครไนซ์ในระดับวัตถุอินสแตนซ์ synchronizedon fun4ถูกซิงโครไนซ์ในระดับอ็อบเจ็กต์คลาส ซึ่งหมายความว่า:

1. เมื่อ 2 เธรดโทรa1.fun1()ในเวลาเดียวกันการโทรครั้งหลังจะถูกบล็อก
2. เมื่อการโทรเธรด 1 a1.fun1()และเธรด 2 โทรa1.fun2()ในเวลาเดียวกันการโทรครั้งหลังจะถูกบล็อก
3. เมื่อการโทรเธรด 1 a1.fun1()และเธรด 2 โทรa1.fun3()ในเวลาเดียวกันจะไม่มีการบล็อก 2 วิธีจะถูกดำเนินการในเวลาเดียวกัน
4. เมื่อเธรด 1 โทรA.fun4()หากเธรดอื่นเรียกA.fun4()หรือA.fun5()ในเวลาเดียวกันการโทรครั้งหลังจะถูกบล็อกเนื่องจากsynchronizedออนfun4คือระดับคลาส
5. เมื่อเธรด 1 โทรA.fun4(), เธรด 2 โทรa1.fun1()ในเวลาเดียวกัน, ไม่มีการบล็อก, 2 วิธีการจะถูกดำเนินการในเวลาเดียวกัน

1. decrementกำลังล็อคสิ่งที่แตกต่างกันincrementเพื่อไม่ให้กันและกันจากการทำงาน
2. การเรียกdecrementใช้อินสแตนซ์หนึ่งกำลังล็อกสิ่งที่แตกต่างกันเพื่อเรียกdecrementใช้อินสแตนซ์อื่น แต่การเรียกใช้อินสแตนซ์หนึ่งจะส่งผลกระทบต่อสิ่งเดียวกัน

ประการแรกหมายถึงการเรียกทับซ้อนกันincrementและdecrementอาจส่งผลให้เกิดการยกเลิก (ถูกต้อง) เพิ่มขึ้นหรือลดลง

ประการที่สองหมายความว่าการเรียกซ้อนกันสองครั้งไปยังdecrementอินสแตนซ์ที่แตกต่างกันอาจส่งผลให้เกิดการลดลงสองครั้ง (ถูกต้อง) หรือการลดลงเพียงครั้งเดียว

เนื่องจากสองวิธีที่แตกต่างกันหนึ่งคือระดับอินสแตนซ์และอื่น ๆ คือระดับคลาสดังนั้นคุณต้องล็อควัตถุที่แตกต่างกัน 2 รายการเพื่อให้เป็น ThreadSafe

ตามที่อธิบายไว้ในคำตอบอื่น ๆ รหัสของคุณไม่ปลอดภัยต่อเธรดเนื่องจากวิธีการแบบคงที่จะincrement()ล็อกการตรวจสอบคลาสและวิธีการที่ไม่คงที่จะdecrement()ล็อกการตรวจสอบวัตถุ

สำหรับตัวอย่างโค้ดนี้มีทางออกที่ดีกว่าโดยไม่ต้องsynchronzedใช้คีย์เวิร์ด คุณต้องใช้AtomicInteger เพื่อให้เกิดความปลอดภัยของเธรด

เธรดปลอดภัยโดยใช้AtomicInteger:

import java.util.concurrent.atomic.AtomicInteger;

class ThreadSafeClass extends Thread {

    private static AtomicInteger count = new AtomicInteger(0);

    public static void increment() {
        count.incrementAndGet();
    }

    public static void decrement() {
        count.decrementAndGet();
    }

    public static int value() {
        return count.get();
    }

}