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

ถ้าฉันมีคลาส util ด้วยวิธีการคงที่ที่จะเรียกใช้ฟังก์ชันไฮเบอร์เนตเพื่อให้เข้าถึงข้อมูลขั้นพื้นฐาน ฉันสงสัยว่าการทำวิธีsynchronizedนี้เป็นวิธีการที่ถูกต้องหรือไม่

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

public class Utils {
     public static synchronized Object getObjectById (Class objclass, Long id) {
           // call hibernate class
         Session session = new Configuration().configure().buildSessionFactory().openSession();
         Object obj = session.load(objclass, id);
         session.close();
         return obj;
     }

     // other static methods
}

เมื่อใช้การซิงโครไนซ์กับการล็อกเมธอดแบบสแตติกคุณจะซิงโครไนซ์วิธีการและแอตทริบิวต์ของคลาส (ตรงข้ามกับวิธีและคุณลักษณะของอินสแตนซ์)

ดังนั้นสมมติฐานของคุณถูกต้อง

ฉันสงสัยว่าการทำวิธีการทำข้อมูลให้ตรงกันนั้นเป็นวิธีการที่ถูกต้องหรือไม่เพื่อความปลอดภัยของเธรด

ไม่ได้จริงๆ คุณควรปล่อยให้ RDBMS ทำงานแทน พวกเขาเก่งเรื่องนี้มาก

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

ลองนึกภาพสถานการณ์ต่อไปนี้:

ไคลเอ็นต์ A และ B พยายามแทรกข้อมูลที่แตกต่างกันในบันทึก X ของตาราง T

ด้วยวิธีการของคุณสิ่งเดียวที่คุณจะได้รับคือการทำให้แน่ใจว่าสิ่งหนึ่งถูกเรียกอีกอย่างหนึ่งเมื่อสิ่งนี้เกิดขึ้นแล้วใน DB เพราะ RDBMS จะป้องกันไม่ให้พวกเขาแทรกข้อมูลครึ่งหนึ่งจาก A และอีกครึ่งหนึ่งจาก B ในเวลาเดียวกัน . ผลลัพธ์จะเหมือนกัน แต่เพียง 5 ครั้ง (หรือมากกว่า) ช้ากว่า

อาจเป็นการดีกว่าที่จะดูบท"ธุรกรรมและการทำงานพร้อมกัน"ในเอกสาร Hibernate ส่วนใหญ่ปัญหาที่คุณพยายามแก้ไขได้รับการแก้ไขแล้วและเป็นวิธีที่ดีกว่ามาก

เพื่อตอบคำถามโดยทั่วไป ...

โปรดทราบว่าการใช้การซิงโครไนซ์กับวิธีการเป็นเพียงการจดชวเลข (สมมติคลาสเป็น SomeClass):

synchronized static void foo() {
    ...
}

เป็นเช่นเดียวกับ

static void foo() {
    synchronized(SomeClass.class) {
        ...
    }
}

และ

synchronized void foo() {
    ...
}

เป็นเช่นเดียวกับ

void foo() {
    synchronized(this) {
        ...
    }
}

คุณสามารถใช้วัตถุใด ๆ เป็นล็อค หากคุณต้องการล็อคชุดย่อยของวิธีคงที่คุณสามารถ

class SomeClass {
    private static final Object LOCK_1 = new Object() {};
    private static final Object LOCK_2 = new Object() {};
    static void foo() {
        synchronized(LOCK_1) {...}
    }
    static void fee() {
        synchronized(LOCK_1) {...}
    }
    static void fie() {
        synchronized(LOCK_2) {...}
    }
    static void fo() {
        synchronized(LOCK_2) {...}
    }
}

(สำหรับวิธีการที่ไม่คงที่คุณจะต้องทำให้การล็อคเป็นฟิลด์ที่ไม่คงที่)

วิธีการคงที่ใช้คลาสเป็นวัตถุสำหรับล็อคซึ่งเป็น Utils.class สำหรับตัวอย่างของคุณ ใช่แล้วมันก็โอเค

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

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

เหตุใดคุณต้องการบังคับให้มีเธรดเดียวเท่านั้นที่สามารถเข้าถึงฐานข้อมูลได้ตลอดเวลา?

มันเป็นงานของไดรเวอร์ฐานข้อมูลที่จะใช้การล็อคที่จำเป็นConnectionเธรดถูกใช้โดยเธรดครั้งละหนึ่งเท่านั้น!

เป็นไปได้มากว่าฐานข้อมูลของคุณสามารถจัดการการเข้าถึงแบบหลายขนานอย่างสมบูรณ์แบบ

หากเป็นสิ่งที่ต้องทำกับข้อมูลในฐานข้อมูลของคุณทำไมไม่ใช้การแยกฐานข้อมูลเพื่อให้บรรลุ?

เพื่อตอบคำถามของคุณใช่แล้ว: synchronizedวิธีการของคุณไม่สามารถดำเนินการได้โดยมากกว่าหนึ่งเธรดในแต่ละครั้ง

วิธีการsynchronizedทำงานของคีย์เวิร์ด Java

เมื่อคุณเพิ่มsynchronizedคำหลักไปยังวิธีการแบบคงที่วิธีการสามารถเรียกได้โดยเธรดเดียวเท่านั้นในแต่ละครั้ง

ในกรณีของคุณทุกวิธีการโทรจะ:

• สร้างใหม่ SessionFactory
• สร้างใหม่ Session
• ดึงเอนทิตี
• คืนเอนทิตีกลับไปที่ผู้โทร

อย่างไรก็ตามสิ่งเหล่านี้เป็นข้อกำหนดของคุณ:

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

ดังนั้นแม้ว่าgetObjectByIdเมธอดจะปลอดภัยต่อเธรดการใช้งานนั้นไม่ถูกต้อง

SessionFactory ปฏิบัติที่ดีที่สุด

SessionFactoryเป็นด้ายปลอดภัยและเป็นวัตถุที่มีราคาแพงมากในการสร้างตามความต้องการที่จะแยกชั้นเรียนกิจการและสร้างตัวแทน metamodel นิติบุคคลภายใน

ดังนั้นคุณไม่ควรสร้างการเรียกใช้เมธอดSessionFactoryทุกครั้งgetObjectById

คุณควรสร้างอินสแตนซ์ซิงเกิลแทน

private static final SessionFactory sessionFactory = new Configuration()
    .configure()
    .buildSessionFactory();

Sessionควรถูกปิด

คุณไม่ได้ปิดSessionในfinallyบล็อกและสิ่งนี้สามารถรั่วไหลของทรัพยากรฐานข้อมูลหากมีข้อผิดพลาดเกิดขึ้นเมื่อโหลดเอนทิตี

ตามSession.loadวิธีการ JavaDocอาจโยน a HibernateExceptionหากไม่พบเอนทิตีในฐานข้อมูล

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

นั่นเป็นเหตุผลที่คุณต้องใช้finallyบล็อกเพื่อปิดSessionเช่นนี้:

public static synchronized Object getObjectById (Class objclass, Long id) {    
     Session session = null;
     try {
         session = sessionFactory.openSession();
         return session.load(objclass, id);
     } finally {
         if(session != null) {
             session.close(); 
         }
     }
 }

การป้องกันการเข้าถึงแบบหลายเธรด

ในกรณีของคุณคุณต้องการให้แน่ใจว่ามีเพียงหนึ่งเธรดเท่านั้นที่สามารถเข้าถึงเอนทิตีนั้น

แต่synchronizedคำหลักป้องกันไม่ให้สองเธรดเรียกgetObjectByIdพร้อมกันเท่านั้น หากทั้งสองเธรดเรียกใช้เมธอดนี้หลังจากที่อื่นคุณจะยังคงมีสองเธรดที่ใช้เอนทิตีนี้

ดังนั้นถ้าคุณต้องการล็อควัตถุฐานข้อมูลที่กำหนดดังนั้นไม่มีเธรดอื่นสามารถแก้ไขได้ดังนั้นคุณต้องใช้การล็อคฐานข้อมูล

synchronizedคำหลักที่ทำงานเฉพาะใน JVM เดียว หากคุณมีหลายเว็บโหนดจะไม่ป้องกันการเข้าถึงหลายเธรดใน JVM หลายรายการ

สิ่งที่คุณต้องทำคือใช้LockModeType.PESSIMISTIC_READหรือLockModeType.PESSIMISTIC_WRITEขณะใช้การเปลี่ยนแปลงกับฐานข้อมูลเช่นนี้:

Session session = null;
EntityTransaction tx = null;

try {
    session = sessionFactory.openSession();

    tx = session.getTransaction();
    tx.begin();

    Post post = session.find(
        Post.class, 
        id, 
        LockModeType.LockModeType.PESSIMISTIC_READ
    );

    post.setTitle("High-Performance Java Perisstence");

    tx.commit();
} catch(Exception e) {
    LOGGER.error("Post entity could not be changed", e);
    if(tx != null) {
        tx.rollback(); 
    }
} finally {
    if(session != null) {
        session.close(); 
    }
}

ดังนั้นนี่คือสิ่งที่ฉันทำ:

• ฉันสร้างใหม่EntityTransactionและเริ่มทำธุรกรรมฐานข้อมูลใหม่
• ฉันโหลดPostเอนทิตีในขณะที่ล็อคล็อกในฐานข้อมูลที่เกี่ยวข้อง
• ฉันเปลี่ยนPostเอนทิตีและยอมรับธุรกรรม
• ในกรณีที่มีExceptionการโยนฉันย้อนกลับการทำธุรกรรม

สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับ ACID และฐานข้อมูลธุรกรรมตรวจสอบบทความนี้เช่นกัน