Grundläggande principer för flertrådning

Optimera kod i Java

Pavlos Kosmetatos

Lead Engineer @Wealthyhood

Sekventiell kontra parallell körning

Sekventiell bearbetning -> operationer sker en i taget
Parallell bearbetning -> flera operationer sker samtidigt

Hur?

Moderna CPU:er har flera kärnor
Tråd: den minsta enheten för programkörning
Flertrådning fördelar arbetet över dessa kärnor

Enkeltrådning är som en enkelfilig väg där bilarna måste följa varandra. Flertrådning är som en flerfältsväg där bilarna kan köra samtidigt!

Använda trådar

Klassen Thread skapar nya körningsflöden
Varje Thread kan köras oberoende

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

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

Processing on thread: Thread-0

Arbeta med flera trådar

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

Parallella strömmar

Strömmar – en Java 8+-funktion för förenklad parallellism
Hanterar automatiskt skapande och hantering av trådar
Två sätt att skapa:
- collection.parallelStream()
- Stream.of(...).parallel()

Exempel på parallella strömmar

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

När parallell bearbetning passar

CPU-intensiva operationer
Oberoende databearbetning
Stora datamängder
Tillgängliga CPU-kärnor > 1
Parallelliseringsomkostnader är sällan lönsamma för:
- Små datamängder
- Enkla operationer

Sammanfattning

Klassen Thread för att skapa parallella körningsflöden
Parallella strömmar för förenklad samlingsbearbetning
Nyttan beror på:
- Typ av arbetsbelastning
- Datamängdens storlek
- Tillgängliga kärnor

Nu kör vi en övning!

Optimera kod i Java