Avoid deadlock in Java in Hindi

How to avoid deadlock in Java in Hindi?

जावा में गतिरोध से कैसे बचें? बहु-थ्रेडिंग के लिए लोकप्रिय जावा साक्षात्कार प्रश्न और सीज़न के स्वाद में से एक है, ज्यादातर वरिष्ठ स्तर पर पूछे जाने वाले प्रश्नों के साथ। 

भले ही समस्या बहुत बुनियादी दिखती है, लेकिन जब आप गहराई में जाना शुरू करते हैं, तो अधिकांश जावा डेवलपर्स अटक जाते हैं।

 java interview के सवालों के साथ शुरू होता है, "deadlock in java?" इसका उत्तर सरल है जब दो या दो से अधिक thread एक दूसरे के लिए इंतजार कर रहे हैं ताकि उन्हें जिस संसाधन (लॉक) की आवश्यकता हो, उसे छोड़ दें और अनंत समय के लिए अटक जाएं, स्थिति को गतिरोध कहा जाता है। यह केवल मल्टीटास्किंग या मल्टी-थ्रेडिंग के मामले में होगा।
 

यदि आप जावा मल्टी-थ्रेडिंग और concurrency में महारत हासिल करने के बारे में गंभीर हैं, तो मेरा सुझाव है कि आप उदमी पर माइकल पोगरेबिंसी द्वारा जावा मल्टीथ्रेडिंग, कॉन्सिरेन्सी, और परफॉर्मेंस ऑप्टिमाइज़ेशन कोर्स पर एक नज़र डालें। 

यह उच्च प्रदर्शन पर जोर देने के साथ जावा में मल्टीथ्रेडिंग, कॉन्सिरेन्सी, और पैरेलल प्रोग्रामिंग में एक विशेषज्ञ बनने के लिए एक उन्नत पाठ्यक्रम है

java deadlock detection in Hindi?

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

एक अन्य तरीका यह है कि जब आप एप्लिकेशन को चलाते समय डेड-लॉक हो जाते हैं, तो उसे ढूंढने का प्रयास करें, थ्रेड डंप लेने की कोशिश करें, लिनक्स में आप इसे कमांड "kill -3" से कर सकते हैं, यह एक एप्लीकेशन में सभी थ्रेड्स की स्थिति को प्रिंट करेगा लॉग फ़ाइल, और आप देख सकते हैं कि कौन सा thread किस ऑब्जेक्ट पर लॉक है।

आप Fastthread.io जैसे टूल का उपयोग करके उस थ्रेड डंप का विश्लेषण कर सकते हैं जो आपको अपने थ्रेड डंप को अपलोड करने और उसका विश्लेषण करने की अनुमति देता है।

दूसरा तरीका jConsole / VisualVM का उपयोग करना है, यह आपको दिखाएगा कि कौन से धागे लॉक हो रहे हैं और किस ऑब्जेक्ट पर।

यदि आप अपने थ्रेड डंप का विश्लेषण करने के लिए समस्या निवारण उपकरण और प्रक्रियाओं के बारे में जानना चाहते हैं, 

तो मेरा सुझाव है कि आप यूरिया लेवी द्वारा प्लुरलसिटी पर जावा थ्रेड डंप्स का विश्लेषण करने पर एक नज़र डालें। 

जावा थ्रेड डंप के बारे में अधिक जानने के लिए एक उन्नत व्यावहारिक पाठ्यक्रम, और अन्य लोकप्रिय उन्नत समस्या निवारण उपकरण के साथ आपको परिचित करता है।

मेरा यह भी सुझाव है कि आप  Java Concurrency in Practice Bundle by Heinz Kabutz,में शामिल हों, जावा में कंसर्ट और मल्टी-थ्रेडिंग में महारत हासिल करने के लिए सबसे उन्नत पाठ्यक्रम सामग्री में से एक। यह ब्रायन गोएत्ज़ द्वारा क्लासिक जावा कॉनक्यूरिटी इन प्रैक्टिस किताब पर आधारित है, जो कि हर जावा डेवलपर के लिए एक अनुशंसित रीडिंग है।

 deadlock in java

Write a Java program that will result in deadlock?

एक बार जब आप पहले वाले प्रश्न का उत्तर दे देते हैं, तो वे आपसे कोड लिखने के लिए कह सकते हैं (write code which will result in a deadlock in Java?)जिसके परिणामस्वरूप जावा में गतिरोध आ जाएगा?

यहाँ मेरा एक संस्करण है

/**
 * Java program to create a deadlock by imposing circular wait.
 * 
 * @author WINDOWS 8
 *
 */
public class DeadLockDemo {

    /*
     * This method request two locks, first String and then Integer
     */
    public void method1() {
        synchronized (String.class) {
            System.out.println("Aquired lock on String.class object");

            synchronized (Integer.class) {
                System.out.println("Aquired lock on Integer.class object");
            }
        }
    }

    /*
     * This method also requests same two lock but in exactly
     * Opposite order i.e. first Integer and then String. 
     * This creates potential deadlock, if one thread holds String lock
     * and other holds Integer lock and they wait for each other, forever.
     */
    public void method2() {
        synchronized (Integer.class) {
            System.out.println("Aquired lock on Integer.class object");

            synchronized (String.class) {
                System.out.println("Aquired lock on String.class object");
            }
        }
    }
}

यदि  method1() और  method2()दोनों को दो या कई थ्रेड द्वारा बुलाया जाएगा, तो गतिरोध का एक अच्छा मौका है क्योंकि यदि मेथड 1 को निष्पादित करते समय थ्रेड 1 स्टिंग ऑब्जेक्ट पर लॉक प्राप्त करता है और मेथड 2 को रन करते समय इंटेगर पर थ्रेड 2 प्राप्त करता है। () दोनों एक-दूसरे का इंतजार कर रहे होंगे कि आगे बढ़ने के लिए इंटेगर और स्ट्रिंग पर lock जारी हो।

यह आरेख ठीक हमारे कार्यक्रम को प्रदर्शित करता है, जहां एक thread एक वस्तु पर एक ताला रखता है और अन्य वस्तु ताले की प्रतीक्षा करता है जो अन्य धागे के स्वामित्व में हैं। 

java deadlock example

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

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

How to avoid deadlock in Java In Hindi?

अब साक्षात्कारकर्ता अंतिम भाग में आता है, जो मेरे विचार में सबसे महत्वपूर्ण है; आप कोड में एक गतिरोध कैसे तय करते हैं? या  How to avoid deadlock in Java?

यदि आपने ऊपर दिए गए कोड को ध्यान से देखा है, तो आपको पता चल गया होगा कि गतिरोध का वास्तविक कारण एक से अधिक threads नहीं हैं, बल्कि जिस तरह से वे लॉक का अनुरोध कर रहे हैं, यदि आप आदेशित पहुंच प्रदान करते हैं तो समस्या हल हो जाएगी।

यहाँ मेरा निश्चित संस्करण है, जो गतिरोध से बचने के लिए गतिरोध से बचता है, बिना किसी पूर्वपरिवर्तन के, गतिरोध के लिए आवश्यक चार स्थितियों में से एक।

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

public class DeadLockFixed {

    /**
     * Both method are now requesting lock in same order, 
     * first Integer and then String.
     * You could have also done reverse e.g. first String and then Integer,
     * both will solve the problem, as long as both method are requesting lock
     * in consistent order.
     */
    public void method1() {
        synchronized (Integer.class) {
            System.out.println("Aquired lock on Integer.class object");

            synchronized (String.class) {
                System.out.println("Aquired lock on String.class object");
            }
        }
    }

    public void method2() {
        synchronized (Integer.class) {
            System.out.println("Aquired lock on Integer.class object");

            synchronized (String.class) {
                System.out.println("Aquired lock on String.class object");
            }
        }
    }
}