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

शुरुआती लोगों के लिए ऑनलाइन Python प्रशिक्षक

Python आसानी से सीखें बिना सिद्धांत के बोझ के। स्वचालित जांच के साथ व्यावहारिक कार्य हल करें और ब्राउज़र में सीधे कोड लिखें।

पाठ्यक्रम शुरू करें

जावा में समवर्तीता और मल्टीथ्रेडिंग: सिद्धांत से व्यवहार तक

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

थ्रेड क्या है और इसे जावा में कैसे बनाएं?

थ्रेड (thread) एक हल्की प्रक्रिया है जो एक एप्लिकेशन के अंतर्गत चलती है। प्रत्येक थ्रेड का अपना कॉल स्टैक होता है और यह अन्य थ्रेड से स्वतंत्र रूप से काम कर सकता है। जावा में थ्रेड बनाने के दो मुख्य तरीके हैं।

तरीका 1: Thread क्लास से इनहेरिटेंस

public class MyThread extends Thread {    @Override    public void run() {        System.out.println("थ्रेड " + getName() + " शुरू हो गया है!");    }

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

तरीका 2: Runnable इंटरफ़ेस को लागू करना

public class MyRunnable implements Runnable {    @Override    public void run() {        System.out.println("थ्रेड Runnable के माध्यम से चल रहा है");    }

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

दूसरे तरीके का उपयोग करने की अनुशंसा की जाती है, क्योंकि इसमें इनहेरिटेंस की आवश्यकता नहीं होती है और यह एक साथ कई इंटरफ़ेस को लागू करने की अनुमति देता है।

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

जब कई थ्रेड एक साथ साझा डेटा तक पहुँचते हैं, तो रेस कंडीशन (race condition) उत्पन्न होती है। इससे बचने के लिए, जावा सिंक्रोनाइज़ेशन तंत्र प्रदान करता है।

synchronized कीवर्ड

जब तक वर्तमान थ्रेड निष्पादन पूरा नहीं कर लेता, तब तक अन्य थ्रेड के लिए विधि या कोड ब्लॉक तक पहुँच को अवरुद्ध करता है:

public class Counter {    private int count = 0;

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

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

Lock का उपयोग करके लॉकिंग

synchronized की तुलना में अधिक लचीला तंत्र। टाइम-आउट सेट करने और बिना ब्लॉकिंग के लॉक प्राप्त करने का प्रयास करने की अनुमति देता है:

import java.util.concurrent.locks.ReentrantLock;

public class SafeCounter {    private final ReentrantLock lock = new ReentrantLock();    private int count = 0;

    public void increment() {        lock.lock();        try {            count++;        } finally {            lock.unlock(); // हमेशा लॉक जारी करें        }    }}

थ्रेड पूल और ExecutorService

प्रत्येक कार्य के लिए नया थ्रेड बनाना एक महँगा ऑपरेशन है। थ्रेड को कुशलतापूर्वक प्रबंधित करने के लिए, java.util.concurrent पैकेज से ExecutorService का उपयोग करें।

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

public class ThreadPoolExample {    public static void main(String[] args) {        // 4 थ्रेड का एक पूल बनाएँ        ExecutorService executor = Executors.newFixedThreadPool(4);

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

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

पूल के मुख्य प्रकार: