सिंक्रनाइज़ेशन बनाम लॉक

Question

java.util.concurrentएपीआई एक वर्ग प्रदान करता है जिसे बुलाया जाता है Lock, जो मूल रूप से महत्वपूर्ण संसाधन तक पहुंचने के लिए नियंत्रण को क्रमबद्ध करेगा। यह जैसे park()और विधि देता है unpark()।

यदि हम synchronizedकीवर्ड का उपयोग कर सकते हैं wait()और notify() notifyAll()विधियों और विधियों का उपयोग कर सकते हैं तो हम भी ऐसा ही कर सकते हैं ।

मैं सोच रहा हूं कि इनमें से कौन सा अभ्यास में बेहतर है और क्यों?

Comments

उपयोगी लेख यहाँ: javarevisited.blogspot.in/2013/03/…

— roottraveller

Answer 1

यदि आप किसी ऑब्जेक्ट को लॉक कर रहे हैं, तो मैं उपयोग करना पसंद करूंगा synchronized

उदाहरण:

Lock.acquire();
doSomethingNifty(); // Throws a NPE!
Lock.release(); // Oh noes, we never release the lock!

आपको try{} finally{}हर जगह स्पष्ट रूप से करना होगा ।

जबकि सिंक्रनाइज़ के साथ, यह सुपर स्पष्ट है और गलत होना असंभव है:

synchronized(myObject) {
    doSomethingNifty();
}

उस ने कहा, Lockअधिक जटिल चीजों के लिए यह अधिक उपयोगी हो सकता है जहां आप इस तरह के स्वच्छ तरीके से अधिग्रहण और रिलीज नहीं कर सकते। मैं ईमानदारी से नंगे का उपयोग कर से बचने के लिए पसंद करेंगे Lockपहली जगह में है, और सिर्फ इस तरह के एक के रूप में एक और अधिक परिष्कृत संगामिति नियंत्रण के साथ जाने CyclicBarrierया LinkedBlockingQueue, अगर वे अपनी जरूरतों को पूरा।

मेरे पास उपयोग करने का कोई कारण नहीं है wait()या notify()कुछ अच्छे भी हो सकते हैं।

Comments

प्रतीक्षा / अधिसूचित बनाम पार्क / लॉकपार्ट के अनपार्क के बीच क्या अंतर है? docs.oracle.com/javase/7/docs/api/java/util/concurrent/locks/…

— Pacerier

पहले उदाहरण में तालों के साथ समझ में आता है, लेकिन फिर मुझे एहसास हुआ कि अगर आप एक कोशिश का उपयोग करते हैं कि अंत में उस समस्या को रोक दिया जाएगा जिसमें ताले जारी न हों

— विलियम रीड

आह ... C ++ में RAII मॉडल की सराहना करने के लिए उन क्षणों में से एक। std::lock_guard

— WhiZTiM

Answer 2

मैं सोच रहा हूं कि इनमें से कौन सा अभ्यास में बेहतर है और क्यों?

मैंने पाया है कि Lockऔर Condition(और अन्य नई concurrentकक्षाएं) टूलबॉक्स के लिए सिर्फ अधिक उपकरण हैं। मैं अपने पुराने पंजे के हथौड़े ( synchronizedकीवर्ड) के साथ अपनी जरूरत की अधिकांश चीजें कर सकता था, लेकिन कुछ स्थितियों में इसका इस्तेमाल करना अजीब था। रबर टूललेट, बॉल-पीन हैमर, प्राइबर, और कुछ नेल पंच: एक बार मैंने अपने टूलबॉक्स में और उपकरण जोड़ दिए तो उनमें से कई अजीब हालात बहुत सरल हो गए। हालांकि , मेरे पुराने पंजे का हथौड़ा अभी भी इसके उपयोग के हिस्से को देखता है।

मुझे नहीं लगता कि एक दूसरे की तुलना में वास्तव में "बेहतर" है, बल्कि प्रत्येक अलग-अलग समस्याओं के लिए बेहतर फिट है। संक्षेप में, सरल मॉडल और गुंजाइश-उन्मुख प्रकृति synchronizedमेरे कोड में कीड़े से बचाने में मदद करती है, लेकिन वही फायदे कभी-कभी अधिक जटिल परिदृश्यों में बाधा बनते हैं। इसका ये अधिक जटिल परिदृश्य है कि समवर्ती पैकेज पते की सहायता के लिए बनाया गया था। लेकिन इस उच्च स्तर के निर्माण का उपयोग करने के लिए कोड में अधिक स्पष्ट और सावधानीपूर्वक प्रबंधन की आवश्यकता होती है।

===

मुझे लगता है कि JavaDoc के बीच अंतर Lockऔर synchronized(जोर मेरा है) का वर्णन करने का एक अच्छा काम करता है :

ताला लागू करने से अधिक व्यापक लॉकिंग ऑपरेशन प्रदान किए जाते हैं जो सिंक्रनाइज़ किए गए तरीकों और बयानों का उपयोग करके प्राप्त किया जा सकता है। वे अधिक लचीली संरचना की अनुमति देते हैं , इसमें काफी भिन्न गुण हो सकते हैं, और कई संबद्ध स्थिति वस्तुओं का समर्थन कर सकते हैं ।

...

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

जबकि सिंक्रनाइज़ किए गए तरीकों और बयानों के लिए स्कोपिंग तंत्र मॉनिटर लॉक के साथ प्रोग्राम करना बहुत आसान बनाता है , और ताले से जुड़े कई सामान्य प्रोग्रामिंग त्रुटियों से बचने में मदद करता है , ऐसे मौके हैं जहां आपको अधिक लचीले तरीके से ताले के साथ काम करने की आवश्यकता होती है। उदाहरण के लिए, समवर्ती रूप से एक्सेस किए गए डेटा स्ट्रक्चर्स को ट्रैवर्स करने के लिए * * कुछ एल्गोरिदम * को "हैंड-ओवर-हैंड" या "चेन लॉकिंग" के उपयोग की आवश्यकता होती है : आप नोड ए का लॉक हासिल करते हैं, फिर नोड बी, फिर ए जारी करते हैं और सी का अधिग्रहण करते हैं, तब बी रिलीज करें और डी और इतने पर अधिग्रहण करें। लॉक इंटरफ़ेस के कार्यान्वयन लॉक को अलग-अलग स्कोप में अधिग्रहित और जारी करने की अनुमति देकर ऐसी तकनीकों के उपयोग को सक्षम करते हैं , औरकिसी भी क्रम में कई तालों को अधिग्रहित और जारी करने की अनुमति देना ।

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

...

जब अलग-अलग स्कोप में लॉकिंग और अनलॉकिंग होती है , तो यह सुनिश्चित करने के लिए ध्यान रखा जाना चाहिए कि लॉक होते समय निष्पादित सभी कोड को ट्राइ-एंड या ट्राइ-कैच द्वारा संरक्षित किया जाता है ताकि यह सुनिश्चित हो सके कि लॉक को आवश्यक होने पर जारी किया गया है।

लॉक कार्यान्वयन प्रदान अतिरिक्त कार्यक्षमता एक प्रदान करके सिंक्रनाइज़ तरीकों और बयानों के उपयोग पर गैर अवरुद्ध प्राप्त करने के लिए प्रयास एक ताला (tryLock ()), के लिए एक प्रयास ताला कि बाधित किया जा सकता प्राप्त करने की कोशिश (lockInterruptibly (), और अधिग्रहण लॉकआउट जो टाइमआउट कर सकता है (tryLock (long, TimeUnit))।

...

Answer 3

आप हर चीज में उपयोगिताओं को प्राप्त कर सकते java.util.concurrent तरह निम्न स्तर के पुरातन के साथ क्या synchronized, volatileया प्रतीक्षा / सूचित

हालाँकि, समसामयिकता मुश्किल है, और अधिकांश लोगों को इसके कुछ हिस्से गलत मिलते हैं, जिससे उनका कोड गलत या अक्षम (या दोनों) हो जाता है।

समवर्ती एपीआई एक उच्च-स्तरीय दृष्टिकोण प्रदान करता है, जो उपयोग करने के लिए आसान (और ऐसे सुरक्षित) है। संक्षेप में, आपको synchronized, volatile, wait, notifyअब सीधे उपयोग करने की आवश्यकता नहीं होनी चाहिए ।

लॉक वर्ग ही इस टूलबॉक्स का निचले स्तर की ओर है, तो आप भी है कि उपयोग करने के लिए सीधे या तो (आप उपयोग कर सकते हैं की आवश्यकता नहीं होती Queuesऔर सेमाफोर और सामान, आदि, ज्यादातर समय)।

Comments

क्या सादे पुराने इंतजार / अधिसूचित को java.util.concurrent.locks की तुलना में निचले स्तर के आदिम माना जाता है।

— पेसरियर

@ स्पेसर: मैं दोनों को निम्न-स्तर का मानता हूं (यानी ऐसा कुछ जो एक प्रोग्रामर प्रोग्रामर सीधे इस्तेमाल से बचना चाहेगा), लेकिन निश्चित रूप से java.util.concurrency (जैसे कि लॉक्स पैकेज) के निचले-स्तर के हिस्से ऊपर बने हैं। देशी JVM प्राइमेटिव्स की प्रतीक्षा करें / सूचित करें (जो और भी निचले स्तर के हैं)।

— थिलो

नहीं, मेरा मतलब 3 में से है: थ्रेड.स्लीप / इंटरप्ट, Object.wait / अधिसूचित, लॉकसुपोर्ट.पार्क / अनपार्क, जो कि सबसे आदिम है?

— पचेरियर

@ थिलो मुझे यकीन नहीं है कि आप अपने कथन का समर्थन कैसे java.util.concurrentकरते हैं जो भाषा की विशेषताओं ( synchronized, आदि ...) की तुलना में आसान है । जब आप उपयोग करते java.util.concurrentहैं तो आपको lock.lock(); try { ... } finally { lock.unlock() }कोड लिखने से पहले पूरा करने की आदत डालनी होती है जबकि आपके साथ synchronizedआप शुरू से ही मूल रूप से ठीक होते हैं। केवल इस आधार पर मैं कहूँगा synchronizedआसान है (आपको इसका व्यवहार चाहिए) java.util.concurrent.locks.Lock। बराबर 4

— इवान ऑकम्प

ऐसा मत सोचो कि आप केवल परमाणु संगति के साथ एटोमिक एक्सएक्सएक्सएक्स क्लास के व्यवहार को दोहरा सकते हैं, क्योंकि वे java.util.concurrent से पहले उपलब्ध नहीं होने वाले देशी कैस इनवोकेशन पर भरोसा करते हैं।

— डंकन आर्मस्ट्रांग

Answer 4

इसमें 4 मुख्य कारक हैं कि आप क्यों उपयोग करना चाहते हैं synchronizedया java.util.concurrent.Lock।

नोट: सिंक्रोनाइज्ड लॉकिंग का मतलब है जब मैं आंतरिक लॉकिंग कहता हूं।

1. जब जावा 5 रीएंन्ट्रान्लॉक्स के साथ बाहर आया, तो वे काफी सुस्पष्ट थ्रूपुट अंतर के बाद आंतरिक लॉकिंग साबित हुए। यदि आप तेजी से लॉकिंग तंत्र की तलाश कर रहे हैं और 1.5 चला रहे हैं तो jucReentrantLock पर विचार करें। जावा 6 का आंतरिक लॉकिंग अब तुलनीय है।

2. jucLock में लॉकिंग के लिए अलग तंत्र हैं। लॉक इंटरप्टेबल - लॉकिंग थ्रेड बाधित होने तक लॉक करने का प्रयास; समय पर ताला - समय की एक निश्चित राशि के लिए बंद करने का प्रयास करें और यदि आप सफल नहीं होते हैं, तो छोड़ दें; tryLock - लॉक करने का प्रयास, यदि कोई अन्य धागा लॉक अप को पकड़े हुए है। यह सब साधारण लॉक से अलग है। आंतरिक लॉकिंग केवल साधारण लॉकिंग प्रदान करता है

3. अंदाज। यदि 1 और 2 दोनों ही उन श्रेणियों की श्रेणी में नहीं आते हैं, जिनका आप सबसे अधिक लोगों से संबंध रखते हैं, जिनमें स्वयं भी शामिल हैं, तो आंतरिक लॉकिंग सेमेनेटिक्स को पढ़ना आसान होता है और कम क्रिया तो jucLock लॉकिंग।
4. कई शर्तें। एक वस्तु जिस पर आप ताला लगाते हैं, उसे केवल अधिसूचित किया जा सकता है और किसी एक मामले की प्रतीक्षा की जा सकती है। लॉक की नई विधि विधि एकल लॉक के लिए उत्परिवर्ती कारणों का इंतजार करने या संकेत करने की अनुमति देती है। मुझे वास्तव में अभ्यास में इस कार्यक्षमता की आवश्यकता है, लेकिन उन लोगों के लिए एक अच्छी सुविधा है जिन्हें इसकी आवश्यकता है।

Comments

मुझे आपकी टिप्पणी पर विवरण पसंद आया। मैं एक और बुलेट बिंदु जोड़ूंगा - ReadWriteLock उपयोगी व्यवहार प्रदान करता है यदि आप कई थ्रेड्स के साथ काम कर रहे हैं, जिनमें से केवल कुछ को ऑब्जेक्ट पर लिखना होगा। एकाधिक थ्रेड्स समवर्ती रूप से ऑब्जेक्ट को पढ़ सकते हैं और केवल तभी ब्लॉक किए जाते हैं यदि कोई अन्य थ्रेड पहले से ही इसे लिख रहा हो।

— सैम गोल्डबर्ग

Answer 5

मैं बर्ट एफ जवाब के शीर्ष पर कुछ और चीजें जोड़ना चाहूंगा ।

Locksमहीन दाने वाले लॉक नियंत्रण के लिए विभिन्न तरीकों का समर्थन करें, जो अंतर्निहित मॉनिटर ( synchronizedताले) की तुलना में अधिक अभिव्यंजक हैं।

एक लॉक साझा संसाधन के लिए अनन्य पहुँच प्रदान करता है: एक समय में केवल एक धागा लॉक का अधिग्रहण कर सकता है और साझा संसाधन तक सभी पहुंच के लिए आवश्यक है कि लॉक को पहले अधिग्रहित किया जाए। हालाँकि, कुछ ताले साझा संसाधन तक समवर्ती पहुँच की अनुमति दे सकते हैं, जैसे कि ReadWriteLock का रीड लॉक।

प्रलेखन पृष्ठ से सिंक्रोनाइज़ेशन पर लॉक का लाभ

1. सिंक्रोनाइज़्ड मेथड्स या स्टेटमेंट्स का उपयोग हर ऑब्जेक्ट से जुड़े निहित मॉनिटर लॉक तक पहुँच प्रदान करता है, लेकिन सभी लॉक अधिग्रहण और रिलीज़ को ब्लॉक-स्ट्रक्चर्ड तरीके से होने के लिए मजबूर करता है।

2. लॉक कार्यान्वयन lock (tryLock()), एक प्राप्त करने के लिए गैर-अवरुद्ध प्रयास , एक अवरोध को प्राप्त करने का प्रयास प्रदान करके और बाधित किया जा सकने वाला लॉक ( lockInterruptibly()और एक लॉक प्राप्त करने का प्रयास करके) अतिरिक्त विधियों के उपयोग पर अतिरिक्त कार्यक्षमता प्रदान करता है timeout (tryLock(long, TimeUnit))।

3. एक लॉक क्लास व्यवहार और शब्दार्थ भी प्रदान कर सकता है जो कि अंतर्निहित मॉनिटर लॉक से काफी अलग होता है, जैसे कि गारंटीकृत ऑर्डर, गैर-रीएन्ट्रेंट उपयोग, या गतिरोध का पता लगाना

ReentrantLock : मेरी समझ के अनुसार सरल शब्दों में, ReentrantLockएक ऑब्जेक्ट को एक महत्वपूर्ण अनुभाग से दूसरे महत्वपूर्ण अनुभाग में फिर से दर्ज करने की अनुमति देता है। चूंकि आपके पास पहले से ही एक महत्वपूर्ण अनुभाग दर्ज करने के लिए ताला है, आप वर्तमान लॉक का उपयोग करके एक ही वस्तु पर अन्य महत्वपूर्ण अनुभाग कर सकते हैं।

ReentrantLockइस लेख के अनुसार मुख्य विशेषताएं

1. बाधा डालने की क्षमता।
2. लॉक का इंतजार करते हुए टाइमआउट करने की क्षमता।
3. निष्पक्ष ताला बनाने की शक्ति।
4. लॉक के लिए प्रतीक्षा धागा की सूची प्राप्त करने के लिए एपीआई।
5. बिना अवरोध के लॉक के लिए प्रयास करने की लचीलापन।

आप उपयोग कर सकते हैं ReentrantReadWriteLock.ReadLock, ReentrantReadWriteLock.WriteLock आगे पढ़ने और लिखने के संचालन पर दानेदार लॉकिंग पर नियंत्रण हासिल करने के लिए ।

इन तीन रेंट्रेंटलॉक्स के अलावा, जावा 8 एक और लॉक प्रदान करता है

StampedLock:

जावा 8 जहाजों को स्टैम्डलॉक नामक एक नए तरह के लॉक के साथ जो ऊपर दिए उदाहरण में पढ़ने और लिखने के लिए लॉक का समर्थन करते हैं। ReadWriteLock के विपरीत स्टैम्पडॉक की लॉकिंग विधियाँ एक स्टैंप को दर्शाती हैं जो एक लंबे मान से दर्शाया जाता है।

आप इन स्टैम्प्स का उपयोग या तो लॉक जारी करने के लिए कर सकते हैं या यह जांचने के लिए कि क्या लॉक अभी भी वैध है। इसके अतिरिक्त मोहरबंद ताले आशावादी लॉकिंग नामक एक अन्य लॉक मोड का समर्थन करते हैं।

विभिन्न प्रकार के और तालों के उपयोग पर इस लेख पर एक नज़र डालें ।ReentrantLockStampedLock

Answer 6

मुख्य अंतर निष्पक्षता है, दूसरे शब्दों में अनुरोधों को FIFO द्वारा नियंत्रित किया जाता है या क्या कोई रोक-टोक हो सकती है? विधि स्तर सिंक्रनाइज़ेशन लॉक के निष्पक्ष या फीफो आवंटन को सुनिश्चित करता है। का उपयोग करते हुए

synchronized(foo) {
}

या

lock.acquire(); .....lock.release();

निष्पक्षता का आश्वासन नहीं देता।

यदि आपके पास लॉक के लिए बहुत सारे विवाद हैं, तो आप आसानी से बारिंग से सामना कर सकते हैं जहां नए अनुरोधों को लॉक मिलता है और पुराने अनुरोध अटक जाते हैं। मैंने ऐसे मामलों को देखा है जहां 200 धागे एक ताला के लिए कम क्रम में आते हैं और दूसरा आने वाला अंतिम संसाधित होता है। यह कुछ अनुप्रयोगों के लिए ठीक है लेकिन दूसरों के लिए यह घातक है।

इस विषय की पूरी चर्चा के लिए ब्रायन गोएत्ज़ की "जावा कंसेंटर इन प्रैक्टिस" पुस्तक देखें।

Comments

"विधि स्तर सिंक्रनाइज़ेशन लॉक के निष्पक्ष या फीफो आवंटन को सुनिश्चित करता है।" => वास्तव में? क्या आप यह कह रहे हैं कि एक सिंक्रनाइज़ विधि {} ब्लॉक में तरीकों की सामग्री को लपेटने की तुलना में एक अलग तरीके से wrt निष्पक्षता का व्यवहार करती है? मुझे ऐसा नहीं लगता, या मैं उस वाक्य को गलत समझ रहा था ...?

— 13

हां, हालांकि आश्चर्यजनक और काउंटर सहज ज्ञान युक्त सही है। गोएत्ज़ की किताब सबसे अच्छी व्याख्या है।

— ब्रायन टैरोबॉक्स

यदि आप @BrianTarbox द्वारा प्रदान किए गए कोड को देखते हैं तो सिंक्रनाइज़ किए गए ब्लॉक लॉक करने के लिए "यह" के अलावा कुछ ऑब्जेक्ट का उपयोग कर रहा है। सिद्धांत रूप में, एक सिंक्रनाइज़ किए गए विधि के बीच कोई अंतर नहीं है और उक्त पद्धति के पूरे शरीर को एक सिंक्रनाइज़ ब्लॉक के अंदर डाल रहा है, जब तक कि ब्लॉक लॉक के साथ "इस" का उपयोग करता है।

— xburgos

उत्तर को उद्धरण शामिल करने के लिए संपादित किया जाना चाहिए, और यह स्पष्ट करना चाहिए कि "आश्वासन" यहां "सांख्यिकीय गारंटी" है, न कि निर्धारक।

— नाथन ह्यूजेस

क्षमा करें, मुझे अभी पता चला है कि मैंने कुछ दिनों पहले इस उत्तर को गलत तरीके से डाउन-वोट किया है। दुर्भाग्य से, SO वर्तमान में मुझे इसे वापस नहीं लेने देगा। आशा है कि मैं इसे बाद में ठीक कर सकता हूं।

— मिको atstlund

Answer 7

ब्रायन गोएत्ज़ की "जावा कंसेंटर इन प्रैक्टिस" पुस्तक, खंड 13.3: "... डिफॉल्ट रीएंन्ट्रालॉक की तरह, आंतरिक लॉकिंग कोई निर्धारक निष्पक्षता की गारंटी नहीं देती है, लेकिन अधिकांश लॉकिंग कार्यान्वयन की सांख्यिकीय निष्पक्षता की गारंटी लगभग सभी स्थितियों के लिए पर्याप्त है ..."

Answer 8

लॉक प्रोग्रामर के जीवन को आसान बनाता है। यहां कुछ स्थितियां हैं जिन्हें लॉक के साथ आसान बनाया जा सकता है।

1. एक विधि में लॉक करें, और अन्य विधि में लॉक जारी करें।
2. आपके पास कोड के दो अलग-अलग टुकड़ों पर काम करने वाले दो धागे हैं, हालाँकि पहला धागा वहाँ पर निर्भरता है दूसरा कोड पूरा करने के लिए इससे पहले कि वह आगे बढ़े (जबकि कुछ अन्य धागे भी एक साथ काम कर रहे हैं)। एक साझा लॉक इस समस्या को काफी आसानी से हल कर सकता है।
3. मॉनिटर लागू करना। उदाहरण के लिए, एक सरल कतार जहां पुट और प्राप्त करने के तरीके कई अलग-अलग थ्रेड्स से निष्पादित होते हैं। हालाँकि, क्या आप लैप को न तो एक ही तरीके से दूसरे पर खत्म करना चाहते हैं, और न ही दोनों तरीकों को ओवरलैप कर सकते हैं। ऐसे मामले में एक निजी लॉक जीवन को बहुत आसान बना देता है।

जबकि, लॉक, और स्थितियाँ सिंक्रनाइज़ पर निर्मित हैं। तो निश्चित रूप से आप उसी लक्ष्य को प्राप्त कर सकते हैं। हालाँकि, यह आपके जीवन को कठिन बना सकता है और आपको वास्तविक समस्या को हल करने से भटका सकता है।

Answer 9

ताला और सिंक्रनाइज़ के बीच प्रमुख अंतर:

• ताले के साथ, आप ताले को किसी भी क्रम में जारी और अधिग्रहित कर सकते हैं।
• सिंक्रनाइज़ के साथ, आप केवल उसी क्रम में ताले को मुक्त कर सकते हैं जिसे वह अधिग्रहित किया गया था।

Answer 10

ब्लॉक को लॉक और सिंक्रोनाइज़ करें दोनों एक ही उद्देश्य पर काम करते हैं लेकिन यह उपयोग पर निर्भर करता है। नीचे के भाग पर विचार करें

void randomFunction(){
.
.
.
synchronize(this){
//do some functionality
}

.
.
.
synchronize(this)
{
// do some functionality
}


} // end of randomFunction

उपरोक्त मामले में, यदि कोई थ्रेड सिंक्रोनाइज़ ब्लॉक में प्रवेश करता है, तो दूसरा ब्लॉक भी लॉक हो जाता है। यदि एक ही ऑब्जेक्ट पर कई ऐसे सिंक्रोनाइज़ ब्लॉक होते हैं, तो सभी ब्लॉक लॉक हो जाते हैं। ऐसी स्थितियों में java.util.concurrent.Lock का इस्तेमाल ब्लॉक की अवांछित लॉकिंग को रोकने के लिए किया जा सकता है