S12L08 - मल्टीथ्रेडिंग में सिंक्रोनाइज़ेशन ब्लॉक

html

Java में Synchronized ब्लॉक्स में महारत हासिल करना: थ्रेड प्रदर्शन को बढ़ाना
विषय सूची

परिचय ................................................. 1
Java में Synchronization को समझना .............................................................. 3

Synchronized मेथड्स बनाम Synchronized ब्लॉक्स


Synchronized ब्लॉक्स को लागू करना ............................................................ 6

कोड कार्यान्वयन
कोड की चरण-दर-चरण व्याख्या


प्रदर्शन विश्लेषण ............................................................ 12

तुलनात्मक तालिका


Synchronization के लिए सर्वोत्तम अभ्यास ............................................................ 16
निष्कर्ष ............................................................ 20


परिचय
Synchronization Java प्रोग्रामिंग में एक बुनियादी अवधारणा है, जो समवर्ती प्रक्रियाओं का प्रबंधन करने और थ्रेड सुरक्षा सुनिश्चित करने के लिए आवश्यक है। जैसे-जैसे अनुप्रयोगों में जटिलता बढ़ती है, प्रदर्शन को अनुकूलित करते हुए डेटा अखंडता बनाए रखना अत्यंत महत्वपूर्ण हो जाता है। यह eBook Java में synchronized ब्लॉक्स की बारीकियों में खुदाई करता है, उन्हें synchronized मेथड्स के साथ तुलना करता है, और दिखाता है कि आंशिक synchronization कैसे महत्वपूर्ण प्रदर्शन सुधारों की ओर ले जा सकता है।
इस गाइड में, हम निम्नलिखित का अन्वेषण करेंगे:

Synchronized मेथड्स और synchronized ब्लॉक्स के बीच के अंतर।
सynchronized ब्लॉक्स को प्रभावी ढंग से लागू कैसे करें।
Synchronized मेथड्स की तुलना में synchronized ब्लॉक्स का उपयोग करने के प्रदर्शन लाभ।
Java अनुप्रयोगों में थ्रेड प्रबंधन को बढ़ाने के सर्वोत्तम अभ्यास।

इस eBook के अंत तक, शुरुआती और बुनियादी ज्ञान वाले डेवलपर्स synchronized ब्लॉक्स की व्यापक समझ प्राप्त करेंगे, जिससे वे अधिक कुशल और थ्रेड-सुरक्षित Java अनुप्रयोग लिख सकें।

Java में Synchronization को समझना
Synchronized मेथड्स बनाम Synchronized ब्लॉक्स
Java में Synchronization सुनिश्चित करता है कि कई थ्रेड्स साझा संसाधनों तक सुरक्षित रूप से पहुंच सकते हैं बिना डेटा असंगति या भ्रष्टाचार का कारण बने। Synchronization प्राप्त करने के दो प्रमुख तरीके हैं:

Synchronized मेथड्स: पूरे मेथड्स को लॉक किया जाता है, जिससे एक समय में केवल एक थ्रेड मेथड को निष्पादित कर सकता है।
Synchronized ब्लॉक्स: केवल मेथड के भीतर विशिष्ट कोड सेक्शन्स को लॉक किया जाता है, जिससे अधिक सूक्ष्म नियंत्रण प्राप्त होता है।

Synchronized मेथड्स
जब किसी मेथड को synchronized कीवर्ड के साथ घोषित किया जाता है, तो पूरा मेथड एक क्रिटिकल सेक्शन बन जाता है। इसका मतलब है कि एक थ्रेड जब मेथड में प्रवेश करता है, तब तक कोई अन्य थ्रेड उसी ऑब्जेक्ट के किसी भी synchronized मेथड तक नहीं पहुंच सकता जब तक कि पहला थ्रेड बाहर नहीं निकलता।




		
		
			
			
Java
			
			
public synchronized void synchronizedMethod() {
    // Critical section
    // Only one thread can execute this method at a time
}

			
				
					
				
					1
2
3
4
5
6
				
						 
public synchronized void synchronizedMethod() {
    // Critical section
    // Only one thread can execute this method at a time
}
 
					
				
			
		


फायदे:

लागू करने के लिए सरल।
पूरे मेथड के लिए पूर्ण थ्रेड सुरक्षा सुनिश्चित करता है।

नुकसान:

यदि पूरे मेथड को Synchronize करने की आवश्यकता नहीं है तो प्रदर्शन बाधाओं का कारण बन सकता है।
Concurrency को कम करता है, क्योंकि थ्रेड्स गैर-क्रिटिकल सेक्शन्स तक भी ब्लॉक हो जाते हैं।

Synchronized ब्लॉक्स
Synchronized ब्लॉक्स डेवलपर्स को मेथड के भीतर केवल विशिष्ट कोड सेक्शन्स को लॉक करने की अनुमति देते हैं। यह दृष्टिकोण Synchronization पर अधिक सूक्ष्म नियंत्रण प्रदान करता है, जिससे बेहतर concurrency के द्वारा प्रदर्शन में सुधार होता है।




		
		
			
			
Java
			
			
public void methodWithSynchronizedBlock() {
    // Non-critical section
    synchronized(this) {
        // Critical section
        // Only one thread can execute this block at a time
    }
    // Non-critical section
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						 
public void methodWithSynchronizedBlock() {
    // Non-critical section
    synchronized(this) {
        // Critical section
        // Only one thread can execute this block at a time
    }
    // Non-critical section
}
 
					
				
			
		


फायदे:

केवल आवश्यक कोड को Synchronize करके प्रदर्शन में सुधार।
बढ़ी हुई concurrency क्योंकि गैर-क्रिटिकल सेक्शन्स अन्य थ्रेड्स के लिए सुलभ रहते हैं।

नुकसान:

Synchronization मुद्दों से बचने के लिए सावधानीपूर्वक कार्यान्वयन की आवश्यकता होती है।
Synchronized मेथड्स की तुलना में थोड़ा अधिक जटिल।


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




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("Synchronization Demo");

        // Synchronized Method Example
        SynchronizedMethodExample methodExample = new SynchronizedMethodExample();
        methodExample.runThreads();

        // Synchronized Block Example
        SynchronizedBlockExample blockExample = new SynchronizedBlockExample();
        blockExample.runThreads();
    }
}

class SynchronizedMethodExample {
    public synchronized void generate() {
        // Generate pattern
        for(int i = 0; i < 10; i++) {
            try {
                Thread.sleep(5);
            } catch(InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Synchronized Method: " + i);
        }
    }

    public void runThreads() throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            long start = System.currentTimeMillis();
            generate();
            long end = System.currentTimeMillis();
            System.out.println("Synchronized Method Time: " + (end - start) + "ms");
        });

        Thread thread2 = new Thread(() -> {
            long start = System.currentTimeMillis();
            generate();
            long end = System.currentTimeMillis();
            System.out.println("Synchronized Method Time: " + (end - start) + "ms");
        });

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();
    }
}

class SynchronizedBlockExample {
    public void generate() {
        // Sync on this block only
        synchronized(this) {
            for(int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(5);
                } catch(InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Synchronized Block: " + i);
            }
        }

        // Non-synchronized section
        for(int i = 0; i < 10; i++) {
            try {
                Thread.sleep(10);
            } catch(InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Non-Synchronized Block: " + i);
        }
    }

    public void runThreads() throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            long start = System.currentTimeMillis();
            generate();
            long end = System.currentTimeMillis();
            System.out.println("Synchronized Block Time: " + (end - start) + "ms");
        });

        Thread thread2 = new Thread(() -> {
            long start = System.currentTimeMillis();
            generate();
            long end = System.currentTimeMillis();
            System.out.println("Synchronized Block Time: " + (end - start) + "ms");
        });

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("Synchronization Demo");
 
        // Synchronized Method Example
        SynchronizedMethodExample methodExample = new SynchronizedMethodExample();
        methodExample.runThreads();
 
        // Synchronized Block Example
        SynchronizedBlockExample blockExample = new SynchronizedBlockExample();
        blockExample.runThreads();
    }
}
 
class SynchronizedMethodExample {
    public synchronized void generate() {
        // Generate pattern
        for(int i = 0; i < 10; i++) {
            try {
                Thread.sleep(5);
            } catch(InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Synchronized Method: " + i);
        }
    }
 
    public void runThreads() throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            long start = System.currentTimeMillis();
            generate();
            long end = System.currentTimeMillis();
            System.out.println("Synchronized Method Time: " + (end - start) + "ms");
        });
 
        Thread thread2 = new Thread(() -> {
            long start = System.currentTimeMillis();
            generate();
            long end = System.currentTimeMillis();
            System.out.println("Synchronized Method Time: " + (end - start) + "ms");
        });
 
        thread1.start();
        thread2.start();
 
        thread1.join();
        thread2.join();
    }
}
 
class SynchronizedBlockExample {
    public void generate() {
        // Sync on this block only
        synchronized(this) {
            for(int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(5);
                } catch(InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Synchronized Block: " + i);
            }
        }
 
        // Non-synchronized section
        for(int i = 0; i < 10; i++) {
            try {
                Thread.sleep(10);
            } catch(InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Non-Synchronized Block: " + i);
        }
    }
 
    public void runThreads() throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            long start = System.currentTimeMillis();
            generate();
            long end = System.currentTimeMillis();
            System.out.println("Synchronized Block Time: " + (end - start) + "ms");
        });
 
        Thread thread2 = new Thread(() -> {
            long start = System.currentTimeMillis();
            generate();
            long end = System.currentTimeMillis();
            System.out.println("Synchronized Block Time: " + (end - start) + "ms");
        });
 
        thread1.start();
        thread2.start();
 
        thread1.join();
        thread2.join();
    }
}
 
					
				
			
		


कोड की चरण-दर-चरण व्याख्या

Main Class:

Synchronization डेमो की शुरुआत करता है।
SynchronizedMethodExample और SynchronizedBlockExample के उदाहरण बनाता है।
दोनों Synchronization दृष्टिकोणों के लिए थ्रेड्स चलाता है।


SynchronizedMethodExample Class:

generate() Method: synchronized के रूप में घोषित, जिससे पूरा मेथड एक क्रिटिकल सेक्शन बन जाता है। प्रत्येक थ्रेड प्रत्येक iteration में 5 मिलिसेकंड के लिए सोता है ताकि प्रोसेसिंग समय का अनुकरण हो सके।
runThreads() Method: दो थ्रेड्स बनाता और शुरू करता है जो generate() मेथड को निष्पादित करते हैं। प्रत्येक थ्रेड के लिए लगने वाले समय को मापता और प्रिंट करता है।


SynchronizedBlockExample Class:

generate() Method:

Synchronized ब्लॉक: केवल पैटर्न उत्पन्न करने वाला for-loop synchronized(this) का उपयोग करके Synchronize किया जाता है। इससे सुनिश्चित होता है कि केवल इस ब्लॉक को लॉक किया गया है, जिससे गैर-क्रिटिकल सेक्शन्स समानांतर रूप से निष्पादित हो सकते हैं।
Non-Synchronized सेक्शन: एक अलग for-loop प्रत्येक iteration में 10 मिलिसेकंड के लिए सोता है बिना Synchronization के।


runThreads() Method: SynchronizedMethodExample की तरह ही, यह दो थ्रेड्स बनाता और शुरू करता है जो generate() मेथड को निष्पादित करते हैं। प्रत्येक थ्रेड के लिए लगने वाले समय को मापता और प्रिंट करता है।


Execution Flow:

मुख्य मेथड दोनों synchronized मेथड्स और synchronized ब्लॉक्स के लिए थ्रेड्स चलाता है।
दोनों दृष्टिकोणों के लिए लगने वाले समय की तुलना करके, हम प्रदर्शन के अंतर को देख सकते हैं।



Program Output
ऊपर दिए गए प्रोग्राम को चलाते समय, आप निम्नलिखित के समान आउटपुट देख सकते हैं:




		
		
			
			
Java
			
			Synchronization Demo
Synchronized Method: 0
Synchronized Method: 1
...
Synchronized Method Time: 50ms
Synchronized Method: 0
Synchronized Method: 1
...
Synchronized Method Time: 50ms
Synchronized Block: 0
Synchronized Block: 1
...
Non-Synchronized Block: 0
Non-Synchronized Block: 1
...
Synchronized Block Time: 80ms
Synchronized Block: 0
Synchronized Block: 1
...
Non-Synchronized Block: 0
Non-Synchronized Block: 1
...
Synchronized Block Time: 80ms
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
				
						Synchronization Demo
Synchronized Method: 0
Synchronized Method: 1
...
Synchronized Method Time: 50ms
Synchronized Method: 0
Synchronized Method: 1
...
Synchronized Method Time: 50ms
Synchronized Block: 0
Synchronized Block: 1
...
Non-Synchronized Block: 0
Non-Synchronized Block: 1
...
Synchronized Block Time: 80ms
Synchronized Block: 0
Synchronized Block: 1
...
Non-Synchronized Block: 0
Non-Synchronized Block: 1
...
Synchronized Block Time: 80ms
					
				
			
		


व्याख्या:

Synchronized मेथड: दोनों थ्रेड्स को पूरे मेथड को निष्पादित करने के लिए इंतजार करना पड़ता है, जिससे कुल निष्पादन समय अधिक हो जाता है।
Synchronized ब्लॉक: केवल क्रिटिकल सेक्शन Synchronize किया जाता है, जिससे गैर-क्रिटिकल सेक्शन्स समानांतर रूप से निष्पादित हो सकते हैं, और कुल निष्पादन समय कम हो जाता है।


प्रदर्शन विश्लेषण
Synchronization रणनीतियों के प्रदर्शन पर प्रभाव को समझना Java अनुप्रयोगों को अनुकूलित करने के लिए महत्वपूर्ण है। निम्न सेक्शन प्रदान किए गए उदाहरण के आधार पर synchronized मेथड्स और synchronized ब्लॉक्स का तुलनात्मक विश्लेषण प्रस्तुत करता है।
तुलनात्मक तालिका


विशेषता
Synchronized मेथड
Synchronized ब्लॉक


Synchronization का क्षेत्र
पूरा मेथड
मेथड के भीतर विशिष्ट कोड ब्लॉक्स


लागू करने में सरलता
सरल, मेथड में synchronized कीवर्ड जोड़ना आवश्यक है
क्रिटिकल सेक्शन्स की पहचान करना और synchronized ब्लॉक्स को लागू करना आवश्यक है


प्रदर्शन पर प्रभाव
पूरे मेथड को लॉक करने के कारण उच्च; संभावित बाधाएँ
केवल क्रिटिकल सेक्शन्स को लॉक करने के कारण कम, जिससे अधिक concurrency संभव है


Concurrency स्तर
कम, क्योंकि केवल एक थ्रेड पूरे मेथड को एक समय में निष्पादित कर सकता है
उच्च, क्योंकि गैर-क्रिटिकल सेक्शन्स को कई थ्रेड्स समानांतर रूप से एक्सेस कर सकते हैं


लचीलापन
कम लचीला, क्योंकि पूरा मेथड एक इकाई के रूप में माना जाता है
अधिक लचीला, कोड आवश्यकताओं के आधार पर चयनात्मक Synchronization सक्षम करना


यूज़ केस उपयुक्तता
जब पूरे मेथड को थ्रेड-सुरक्षित बनाने की आवश्यकता हो तब उपयुक्त
जब केवल मेथड के विशिष्ट हिस्सों को Synchronize करने की आवश्यकता हो तब उपयुक्त


प्रेक्षित प्रदर्शन मीट्रिक
उदाहरण प्रोग्राम के आधार पर:

Synchronized मेथड:

समय आवश्यकता: प्रति थ्रेड लगभग 50ms।
कुल समय: पूरे मेथड Synchronization के कारण उच्च।


Synchronized ब्लॉक:

समय आवश्यकता: प्रति थ्रेड लगभग 80ms।
कुल समय: synchronized मेथड्स की तुलना में कम, क्योंकि गैर-क्रिटिकल सेक्शन्स समानांतर रूप से चलते हैं।



निष्कर्ष: Synchronized ब्लॉक्स बेहतर प्रदर्शन प्रदान करते हैं क्योंकि वे कोड के गैर-क्रिटिकल सेक्शन्स को समानांतर निष्पादित करने देते हैं, जिससे कुल निष्पादन समय कम होता है।

Synchronization के लिए सर्वोत्तम अभ्यास
Synchronized ब्लॉक्स की पूरी क्षमता का लाभ उठाने और कुशल थ्रेड प्रबंधन सुनिश्चित करने के लिए, निम्नलिखित सर्वोत्तम अभ्यासों पर विचार करें:

Synchronization के क्षेत्र को न्यूनतम करें:

केवल उन क्रिटिकल सेक्शन्स को Synchronize करें जो थ्रेड सुरक्षा आवश्यक हैं।
जब आवश्यक न हो तो पूरे मेथड को Synchronize करने से बचें।


समर्पित लॉक ऑब्जेक्ट्स का उपयोग करें:

this का उपयोग करने के बजाय, निजी अंतिम लॉक ऑब्जेक्ट्स का उपयोग करें ताकि बाहरी हस्तक्षेप से बचा जा सके।
उदाहरण:







		
		
			
			
Java
			
			
private final Object lock = new Object();

public void method() {
    synchronized(lock) {
        // Critical section
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						 
private final Object lock = new Object();
 
public void method() {
    synchronized(lock) {
        // Critical section
    }
}
 
					
				
			
		



Nested Synchronization से बचें:

जटिलता और संभावित deadlocks को कम करने के लिए synchronized ब्लॉक्स की गहरी नेस्टिंग को न्यूनतम करें।


उच्च-स्तरीय Concurrency उपकरणों को प्राथमिकता दें:

अधिक उन्नत Synchronization आवश्यकताओं के लिए java.util.concurrent पैकेज से ReentrantLock, Semaphore, और CountDownLatch जैसी क्लासेज़ का उपयोग करें।


Deadlocks से सावधान रहें:

Threads के अनंत प्रतीक्षा से बचने के लिए सुनिश्चित करें कि कई लॉक्स को एक सुसंगत क्रम में अधिग्रहित किया जाता है।


प्रदर्शन पर प्रभाव का आकलन करें:

आपके अनुप्रयोग के Synchronization bottlenecks की पहचान करने के लिए प्रोफाइल करें।
सार्वजनिक डेटा के आधार पर Synchronization रणनीतियों को अनुकूलित करें।


Synchronization लॉजिक का दस्तावेजीकरण करें:

भविष्य के रखरखाव और सहयोग में सहायता के लिए synchronized ब्लॉक्स का उद्देश्य और क्षेत्र स्पष्ट रूप से दस्तावेजीकरण करें।




निष्कर्ष
Synchronization Java में concurrent प्रोग्रामिंग का एक महत्वपूर्ण पहलू है, यह सुनिश्चित करता है कि साझा संसाधनों तक कई थ्रेड्स सुरक्षित रूप से पहुंच सकें। जबकि synchronized मेथड्स थ्रेड सुरक्षा प्राप्त करने का एक सीधा तरीका प्रदान करते हैं, वे पूरे मेथड को लॉक करके प्रदर्शन सीमाओं का परिचय दे सकते हैं। दूसरी ओर, synchronized ब्लॉक्स अधिक सूक्ष्म नियंत्रण प्रदान करते हैं, जिससे डेवलपर्स केवल आवश्यक कोड सेक्शन्स को Synchronize कर सकते हैं। यह दृष्टिकोण न केवल अनावश्यक लॉकिंग को कम करके प्रदर्शन में सुधार करता है बल्कि अनुप्रयोगों के concurrency स्तर को भी बढ़ाता है।
इस eBook में, हमने synchronized मेथड्स और synchronized ब्लॉक्स के बीच के अंतर को अन्वेषण किया, दोनों दृष्टिकोणों को एक Java प्रोग्राम में लागू किया, और synchronized ब्लॉक्स के उपयोग से प्राप्त कुशलताओं का प्रदर्शन करते हुए प्रदर्शन विश्लेषण किया। सर्वोत्तम अभ्यासों का पालन करके और सोचे-समझे Synchronization रणनीतियों को लागू करके, डेवलपर्स मजबूत, उच्च-प्रदर्शन Java अनुप्रयोग बना सकते हैं जो जटिल concurrent operations को संभालने में सक्षम हैं।
SEO Keywords: Java synchronization, synchronized blocks, synchronized methods, thread safety, Java concurrency, performance optimization, Java multithreading, thread management, Java programming best practices, concurrent programming Java, synchronization in Java, Java thread performance, partial synchronization, Java synchronized example
नोट: यह लेख AI द्वारा उत्पन्न किया गया है।
विशेषता	Synchronized मेथड	Synchronized ब्लॉक
Synchronization का क्षेत्र	पूरा मेथड	मेथड के भीतर विशिष्ट कोड ब्लॉक्स
लागू करने में सरलता	सरल, मेथड में synchronized कीवर्ड जोड़ना आवश्यक है	क्रिटिकल सेक्शन्स की पहचान करना और synchronized ब्लॉक्स को लागू करना आवश्यक है
प्रदर्शन पर प्रभाव	पूरे मेथड को लॉक करने के कारण उच्च; संभावित बाधाएँ	केवल क्रिटिकल सेक्शन्स को लॉक करने के कारण कम, जिससे अधिक concurrency संभव है
Concurrency स्तर	कम, क्योंकि केवल एक थ्रेड पूरे मेथड को एक समय में निष्पादित कर सकता है	उच्च, क्योंकि गैर-क्रिटिकल सेक्शन्स को कई थ्रेड्स समानांतर रूप से एक्सेस कर सकते हैं
लचीलापन	कम लचीला, क्योंकि पूरा मेथड एक इकाई के रूप में माना जाता है	अधिक लचीला, कोड आवश्यकताओं के आधार पर चयनात्मक Synchronization सक्षम करना
यूज़ केस उपयुक्तता	जब पूरे मेथड को थ्रेड-सुरक्षित बनाने की आवश्यकता हो तब उपयुक्त	जब केवल मेथड के विशिष्ट हिस्सों को Synchronize करने की आवश्यकता हो तब उपयुक्त