मल्टी-थ्रेडिंग के बेसिक सिद्धांत

Java में कोड ऑप्टिमाइज़ करना

Pavlos Kosmetatos

Lead Engineer @Wealthyhood

Sequential बनाम parallel execution

Sequential processing -> ऑपरेशन एक के बाद एक होते हैं
Parallel processing -> कई ऑपरेशन साथ-साथ होते हैं

कैसे?

Modern CPUs में कई cores होते हैं
Thread: प्रोग्राम execution की सबसे छोटी unit
Multi-threading काम को इन cores में बाँटता है

Single-threading एक सिंगल-लेन सड़क जैसी है जहाँ गाड़ियाँ क्रम से चलती हैं. Multi-threading मल्टी-लेन सड़क जैसी है जहाँ कई गाड़ियाँ साथ चल सकती हैं!

Threads का उपयोग

Thread क्लास नए execution paths बनाने देता है
हर Thread independently execute कर सकता है

Runnable task = () -> {
    System.out.println("Processing on thread: " + 
                       Thread.currentThread().getName());
};

Thread thread = new Thread(task);
thread.start();

Processing on thread: Thread-0

Multiple threads के साथ काम

List<Thread> threads = new ArrayList<Thread>();
for (int i = 0; i < 4; i++) {
    Thread thread = new Thread(() -> System.out.println("Processing data on Thread-" + i));
    threads.add(thread);
    thread.start();
}

for (Thread t : threads) {
    t.join(); // Waits for all threads to complete
}

// Processing data on Thread-0
// Processing data on Thread-2
// Processing data on Thread-1
// Processing data on Thread-3

Parallel streams

Streams - Java 8+ फीचर जो parallelism आसान बनाता है
Thread creation और management अपने आप हैंडल होता है
बनाने के दो तरीके:
- collection.parallelStream()
- Stream.of(...).parallel()

Parallel streams उदाहरण

// Sequential processing
List<Integer> result1 = new ArrayList<>();
for (int i = 0; i < numbers.size(); i++) {
    result1.add(numbers.get(i) * 2);
}

// Sequential processing with stream
List<Integer> result2 = numbers.stream()
    .map(n -> n * 2)
    .collect(Collectors.toList());


// Parallel processing with parallel stream
List<Integer> result3 = numbers.parallelStream()
    .map(n -> n * 2)
    .collect(Collectors.toList());

Parallel processing कब उपयोग करें

CPU-intensive ऑपरेशन
Independent data processing
बड़े data collections
Available CPU cores > 1
Parallelization का ओवरहेड इन मामलों में फायदेमंद नहीं हो सकता:
- छोटे data sets
- सरल operations

सारांश

Parallel execution paths बनाने के लिए Thread क्लास
Collections को सरलता से process करने के लिए parallel streams
लाभ निर्भर करते हैं:
- Workload के प्रकार पर
- Data size पर
- Available cores पर

अभ्यास करते हैं!

Java में कोड ऑप्टिमाइज़ करना