Threads und Nebenläufigkeit

public class Faeden {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            try { Thread.sleep(100); } catch (InterruptedException e) { }
            System.out.println("t1 fertig");
        });
        Thread t2 = new Thread(() -> System.out.println("t2 fertig"));
        t1.start();
        t2.start();
        t1.join();                      // warten, bis t1 beendet ist
        t2.join();
        System.out.println("alle fertig");
    }
}

t2 fertig
t1 fertig
alle fertig

public class Wettlauf {
    static int zaehler = 0;
    static final Object sperre = new Object();

    static void erhoehe(boolean sicher) {
        for (int i = 0; i < 100_000; i++) {
            if (sicher) synchronized (sperre) { zaehler++; }
            else zaehler++;                          // nicht atomar: Updates gehen verloren
        }
    }
    static int lauf(boolean sicher) throws InterruptedException {
        zaehler = 0;
        Thread[] t = new Thread[4];
        for (int i = 0; i < t.length; i++) { t[i] = new Thread(() -> erhoehe(sicher)); t[i].start(); }
        for (Thread x : t) x.join();
        return zaehler;
    }
    public static void main(String[] args) throws InterruptedException {
        System.out.println("mit synchronized: " + lauf(true));
        System.out.println("ohne Schutz kleiner als 400000: " + (lauf(false) < 400_000));
    }
}

mit synchronized: 400000
ohne Schutz kleiner als 400000: true

import java.util.concurrent.*;
import java.util.concurrent.atomic.*;

public class Atomar {
    public static void main(String[] args) throws Exception {
        AtomicInteger z = new AtomicInteger();
        ConcurrentHashMap<String, Integer> karte = new ConcurrentHashMap<>();
        ExecutorService pool = Executors.newFixedThreadPool(4);
        for (int i = 0; i < 4; i++) {
            pool.submit(() -> {
                for (int k = 0; k < 10_000; k++) { z.incrementAndGet(); karte.merge("x", 1, Integer::sum); }
            });
        }
        pool.shutdown();
        pool.awaitTermination(5, TimeUnit.SECONDS);
        System.out.println(z.get() + " " + karte.get("x"));
    }
}

40000 40000

import java.util.*;
import java.util.concurrent.*;

public class Pool {
    public static void main(String[] args) throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(3);
        List<Future<Integer>> ergebnisse = new ArrayList<>();
        for (int n = 1; n <= 5; n++) {
            final int zahl = n;
            ergebnisse.add(pool.submit(() -> {              // Callable: liefert ein Ergebnis
                Thread.sleep(50);
                return zahl * zahl;
            }));
        }
        int summe = 0;
        for (Future<Integer> f : ergebnisse) summe += f.get();     // wartet auf das Ergebnis
        System.out.println(summe);
        pool.shutdown();
    }
}

55

import java.util.concurrent.*;

public class Zukunft {
    static CompletableFuture<Integer> laden(int id) {
        return CompletableFuture.supplyAsync(() -> {
            try { Thread.sleep(50); } catch (InterruptedException e) { }
            return id * 10;
        });
    }
    public static void main(String[] args) throws Exception {
        CompletableFuture<Integer> a = laden(1), b = laden(2);
        CompletableFuture<Integer> summe = a.thenCombine(b, Integer::sum);
        System.out.println(summe.thenApply(x -> "Summe: " + x).get());

        CompletableFuture<String> fehler = CompletableFuture
            .<String>supplyAsync(() -> { throw new IllegalStateException("kaputt"); })
            .exceptionally(e -> "Ersatzwert (" + e.getCause().getMessage() + ")");
        System.out.println(fehler.get());

        CompletableFuture.allOf(laden(1), laden(2), laden(3)).get();
        System.out.println("alle drei fertig");
    }
}

Summe: 30
Ersatzwert (kaputt)
alle drei fertig

import java.util.concurrent.*;
import java.util.stream.*;

public class Virtuell {
    public static void main(String[] args) throws Exception {
        try (var pool = Executors.newVirtualThreadPerTaskExecutor()) {
            var aufgaben = IntStream.range(0, 1000).mapToObj(i -> pool.submit(() -> {
                Thread.sleep(10);                 // blockiert nur den virtuellen Thread
                return i;
            })).toList();
            long summe = 0;
            for (var f : aufgaben) summe += f.get();
            System.out.println(summe);
        }
    }
}

499500