जेपीए नेस्टेड लेन-देन और लॉकिंग

Question

परिदृश्य पर विचार करें दो तरीकों अलग राज्यविहीन सेम में मौजूद है

public class Bean_A { 
    Bean_B beanB; // Injected or whatever 
    public void methodA() { 
    Entity e1 = // get from db 
    e1.setName("Blah"); 
    entityManager.persist(e1); 
    int age = beanB.methodB(); 

    } 
} 
public class Bean_B { 
    //Note transaction 
    @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW) 
    public void methodB() { 

    // complex calc to calculate age 
    } 

} 

BeanA.methodA द्वारा शुरू किया लेन-देन निलंबित कर दिया जाएगा और नए लेनदेन BeanB.methodB में शुरू किया जाएगा। क्या होगा यदि विधिबी को विधि ए द्वारा संशोधित एक ही इकाई तक पहुंचने की आवश्यकता हो। इसका परिणाम डेडलॉक होगा। क्या अलगाव स्तर पर भरोसा किए बिना इसे रोकना संभव है?

Answer 1

एचएम, चलो सभी मामलों की सूची।

REQUIRES_NEW वास्तव में लेनदेन घोंसला नहीं करता है, लेकिन जैसा कि आपने बताया है कि वर्तमान में रोक दिया गया है। फिर एक ही जानकारी तक पहुंचने के लिए केवल दो लेन-देन होते हैं। (यह दो नियमित समवर्ती लेनदेन के समान है, सिवाय इसके कि वे समवर्ती नहीं हैं लेकिन निष्पादन के समान धागे में हैं)।

T1 T2   T1 T2 
―    ― 
|    | 
       | 
    ―   | ― 
    |   | | 
    |  =  | | 
    ―   | ― 
       | 
|    | 
―    ― 

फिर हम आशावादी बनाम निराशावादी लॉकिंग पर विचार करने की जरूरत है।

इसके अलावा, हमें पर विचार करने की आवश्यकता है ORM द्वारा संचालित। ORMs के साथ, हम के बाद से flush ढांचे द्वारा नियंत्रित किया जाता है, जब राईट होता है एक स्पष्ट नियंत्रण नहीं है,। आमतौर पर, एक अंतर्निहित फ्लश होता है से पहले प्रतिबद्ध है, लेकिन अगर कई प्रविष्टियों संशोधित कर रहे हैं, ढांचे के रूप में अच्छी तरह से मध्यवर्ती flushes कर सकते हैं।

1) आइए आशावादी लॉकिंग पर विचार करें, जहां ताले हासिल नहीं करते हैं, लेकिन विशिष्ट ताले हासिल करते हैं।

टी 1 द्वारा पढ़ा गया लॉक प्राप्त नहीं करता है।

1 ए) यदि टी 1 ने स्वाभाविक रूप से परिवर्तनों को फ्लश किया था, तो उसने एक विशेष लॉक हासिल किया था। जब टी 2 काम करता है, तो यह लॉक हासिल करने का प्रयास करता है लेकिन नहीं कर सकता। सिस्टम अवरुद्ध है। यह किसी विशेष प्रकार की डेडलॉक के बावजूद हो सकता है। पूरा करने पर निर्भर करता है कि लेन-देन या ताले कैसे समय निकालते हैं।

1 बी) यदि टी 1 ने स्वाभाविक रूप से परिवर्तनों को फ्लश नहीं किया है, तो कोई लॉक अधिग्रहण नहीं किया गया है। जब टी 2 काम करता है, तो यह प्राप्त करता है और इसे रिलीज़ करता है और सफल होता है। जब टी 1 प्रतिबद्ध करने का प्रयास करता है, तो यह एक संघर्ष को नोटिस करता है और विफल रहता है।

2) चलो निराशावादी लॉकिंग पर विचार करें, जहां साझा ताले हासिल करें और विशेष ताले लिखें।

टी 1 द्वारा पढ़ा गया एक साझा लॉक प्राप्त करें।

2 ए) यदि टी 1 प्रक्षेपित रूप से फ्लश हो जाता है, तो यह लॉक इंट को एक विशेष लॉक बदल देता है। स्थिति 1 ए के समान है)

2 बी) यदि टी 1 ने स्वाभाविक रूप से फ्लश नहीं किया है, तो टी 1 में एक साझा लॉक है। जब टी 2 प्रतिबद्ध होता है, तो यह एक विशेष लॉक और ब्लॉक प्राप्त करने का प्रयास करता है। सिस्टम को फिर से अवरुद्ध कर दिया गया है।

निष्कर्ष: यदि कोई समयपूर्व फ्लश नहीं होता है तो यह आशावादी लॉकिंग के साथ ठीक है, जिसे आप कड़ाई से नियंत्रित नहीं कर सकते हैं।

Answer 2

entityManager.persist(e1); के बाद और int age = beanB.methodB(); से पहले लेनदेन करने के द्वारा प्रोग्रामिंग कर रहा है?

public class Bean_A { 
    Bean_B beanB; // Injected or whatever 
    public void methodA() { 
    EntityManager em = createEntityManager(); 
    Entity e1 = // get from db 
    e1.setName("Blah"); 
    entityManager.persist(e1); 
    em.getTransaction().commit(); 
    int age = beanB.methodB(); 

    } 
} 
public class Bean_B { 
    //Note transaction 
    @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW) 
    public void methodB() { 

    // complex calc to calculate age 
    } 

} 

संपादित: CMT

यदि आप CMT, आप अभी भी प्रोग्राम के लिए प्रतिबद्ध कर सकते हैं, तो आप सिर्फ लेन-देन EJBContext से मिलता है। उदाहरण: http://geertschuring.wordpress.com/2008/10/07/how-to-use-bean-managed-transactions-with-ejb3-jpa-and-jta/

या आप @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW) public void methodC() जोड़ सकते हैं जो e1.setName("Blah"); entityManager.persist(e1); करेगा, यानी, यह एक लेनदेन में ई 1 जारी रहेगा। फिर अपने methodA()

methodC(); 
beanB.methodB(); 

Answer 3

यहाँ कहेंगे REQUIRES_NEW लेनदेन सीमांकन के उपयोग के बारे में recent article है।

मेरे अनुभव से, वहाँ मानक कोड के साथ कोई मृत लॉक होना चाहिए: प्रतिबंधात्मक where खंड और कुछ आवेषण के साथ किए जाते हैं। कुछ विशिष्ट मामलों में, कुछ डेटाबेस इंजन लॉक एस्केलेशन कर सकते हैं यदि लेन-देन के दौरान एक ही टेबल पर कई पंक्तियां पढ़ी जाती हैं या डाली जाती हैं ... और उस स्थिति में, हाँ एक मृत-लॉक हो सकता है।

लेकिन उस स्थिति में, समस्या REQUIRES_NEW से नहीं बल्कि SQL डिज़ाइन से आती है। यदि उस डिज़ाइन में सुधार नहीं किया जा सकता है, तो आपके पास अलगाव स्तर को और अधिक ढीले स्तर में बदलने के लिए कोई अन्य विकल्प नहीं है।

Answer 4

इकाई दर्रा और मर्ज ...

आप methodB() के लिए अपने नए इकाई पारित कर सकते हैं, और नए EntityManager को यह मर्ज करें। जब विधि रिटर्न अपनी इकाई को ताज़ा परिवर्तन देखने के लिए:

public class Bean_A { 
    Bean_B beanB; // Injected or whatever 
    public void methodA() { 
    Entity e1 = // get from db 
    e1.setName("Blah"); 
    entityManager.persist(e1); 
    int age = beanB.methodB(e1); 
    entityManager.refresh(e1); 
    } 
} 

public class Bean_B { 
    //Note transaction 
    @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW) 
    public void methodB(Entity e1) { 
    e1 = entityManager.merge(e1); 
    // complex calc to calculate age 
    } 

} 

नोट जब नए लेन-देन methodB के बाद बंद कर देता है कि यह आपके इकाई के लिए प्रतिबद्ध होगा।

... या methodB

कॉल करने से पहले इसे सहेजें आप इकाई अपने मुख्य लेन-देन से अलग से सहेजा जाता है उपरोक्त विधि का उपयोग करते हैं, तो आप नहीं ढीला कुछ भी आप कॉल करने से पहले Bean_A से बचाने अगर methodB():

public class Bean_A { 
    Bean_B beanB; // Injected or whatever 

    @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW) 
    public void createEntity() { 
    Entity e1 = // get from db 
    e1.setName("Blah"); 
    entityManager.persist(e1); 
    } 

    public void methodA() { 
    createEntity() 
    int age = beanB.methodB(); 
    } 
} 

public class Bean_B { 
    //Note transaction 
    @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW) 
    public void methodB() { 

    // complex calc to calculate age 
    } 

}