Podstawowe zasady wielowątkowości

Optymalizacja kodu w Javie

Pavlos Kosmetatos

Lead Engineer @Wealthyhood

Wykonanie sekwencyjne a równoległe

Przetwarzanie sekwencyjne -> operacje wykonywane jedna po drugiej
Przetwarzanie równoległe -> wiele operacji wykonywanych jednocześnie

Jak to działa?

Nowoczesne procesory mają wiele rdzeni
Wątek: najmniejsza jednostka wykonania programu
Wielowątkowość rozdziela pracę między te rdzenie

Jednowątkowość przypomina jednopasową drogę, po której samochody jadą jeden za drugim. Wielowątkowość to wielopasmowa autostrada, gdzie samochody jadą jednocześnie!

Korzystanie z wątków

Klasa Thread umożliwia tworzenie nowych ścieżek wykonania
Każdy Thread może działać niezależnie

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

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

Processing on thread: Thread-0

Praca z wieloma wątkami

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

Strumienie równoległe

Strumienie – funkcja Java 8+ upraszczająca równoległość
Automatycznie zarządza tworzeniem wątków
Dwa sposoby tworzenia:
- collection.parallelStream()
- Stream.of(...).parallel()

Przykład strumieni równoległych

// 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());

Kiedy stosować przetwarzanie równoległe

Operacje intensywne obliczeniowo
Niezależne przetwarzanie danych
Duże kolekcje danych
Dostępne rdzenie CPU > 1
Narzut zrównoleglenia może być nieopłacalny dla:
- Małych zbiorów danych
- Prostych operacji

Podsumowanie

Klasa Thread do tworzenia równoległych ścieżek wykonania
Strumienie równoległe do uproszczonego przetwarzania kolekcji
Korzyści zależą od:
- Rodzaju obciążenia
- Rozmiaru danych
- Dostępnych rdzeni

Czas na ćwiczenia!

Optymalizacja kodu w Javie