जावा में कंकरेंसी और मल्टीथ्रेडिंग: एक संपूर्ण गाइड

Java में कंकरेंसी और मल्टीथ्रेडिंग: बुनियादी से लेकर उन्नत तकनीकों तक

आधुनिक एप्लिकेशन अधिकतम प्रदर्शन की मांग करते हैं। Java में, कंकरेंसी और मल्टीथ्रेडिंग मल्टी-कोर प्रोसेसर के कुशल उपयोग के लिए प्रमुख उपकरण हैं। इस लेख में, हम थ्रेड्स, सिंक्रोनाइज़ेशन और आधुनिक कंकरेंसी यूटिलिटीज़ के साथ सही तरीके से काम करने का तरीका समझेंगे।

Java में मल्टीथ्रेडिंग क्या है?

मल्टीथ्रेडिंग एक प्रोग्राम की एक साथ कई कार्यों को निष्पादित करने की क्षमता है। Java में, प्रत्येक थ्रेड एक हल्का प्रोसेस होता है जिसका अपना कॉल स्टैक होता है। मुख्य लाभ:

• समानांतर निष्पादन के माध्यम से प्रदर्शन में वृद्धि
• अधिक उत्तरदायी यूज़र इंटरफ़ेस
• CPU संसाधनों का कुशल उपयोग

थ्रेड बनाना: दो दृष्टिकोण

Java में थ्रेड बनाने के दो मुख्य तरीके हैं:

1. Thread क्लास से इनहेरिटेंस

public class MyThread extends Thread {    @Override    public void run() {        System.out.println("थ्रेड निष्पादित हो रहा है: " + Thread.currentThread().getName());    }

    public static void main(String[] args) {        MyThread thread = new MyThread();        thread.start(); // थ्रेड शुरू करना    }}

2. Runnable इंटरफ़ेस का कार्यान्वयन

public class Task implements Runnable {    @Override    public void run() {        System.out.println("कार्य थ्रेड में निष्पादित हो रहा है: " + Thread.currentThread().getName());    }

    public static void main(String[] args) {        Thread thread = new Thread(new Task());        thread.start();    }}

Runnable का उपयोग करने की अनुशंसा की जाती है, क्योंकि यह अन्य क्लासेज़ से इनहेरिटेंस की संभावना को सीमित नहीं करता है।

थ्रेड सिंक्रोनाइज़ेशन: race condition से बचना

जब कई थ्रेड साझा डेटा तक पहुँचते हैं, तो सिंक्रोनाइज़ेशन समस्याएँ उत्पन्न होती हैं। आइए एक क्लासिक उदाहरण देखें — काउंटर:

public class Counter {    private int count = 0;

    public synchronized void increment() {        count++;    }

    public synchronized int getCount() {        return count;    }}

कीवर्ड synchronized गारंटी देता है कि एक समय में केवल एक थ्रेड ही मेथड को निष्पादित कर सकता है। विकल्प — java.util.concurrent.locks पैकेज से Lock का उपयोग करना है।

Deadlock: आपसी ब्लॉकिंग से कैसे बचें

Deadlock तब होता है जब दो थ्रेड एक-दूसरे के संसाधनों के जारी होने की प्रतीक्षा करते हैं। उदाहरण:

public class DeadlockExample {    private final Object lock1 = new Object();    private final Object lock2 = new Object();

    public void method1() {        synchronized (lock1) {            synchronized (lock2) {                // क्रिटिकल सेक्शन            }        }    }

    public void method2() {        synchronized (lock2) {            synchronized (lock1) {                // क्रिटिकल सेक्शन            }        }    }}

Deadlock से बचने के लिए, हमेशा लॉक को एक ही क्रम में प्राप्त करें या टाइमआउट के साथ tryLock() का उपयोग करें।

ExecutorService: थ्रेड पूल का प्रबंधन

मैन्युअल रूप से थ्रेड बनाना अकुशल है। Java थ्रेड पूल के प्रबंधन के लिए ExecutorService प्रदान करता है:

import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;

public class ThreadPoolExample {    public static void main(String[] args) {        ExecutorService executor = Executors.newFixedThreadPool(4);

        for (int i = 0; i < 10; i++) {            executor.submit(() -> {                System.out.println("निष्पादित हो रहा है: " + Thread.currentThread().getName());            });        }

        executor.shutdown(); // सभी कार्यों के निष्पादन के बाद समाप्ति    }}

मुख्य बातें