Moderne concurrency i Java

"tråder" vs "oppgaver"

Vanligvis bryr vi oss ikke om tråder, vi vil bare gjøre ting "i bakgrunnen" eller "parallellt".

"tråder" vs "oppgaver"

Time for a task to complete in a new Thread 71.3 us
Time for a task to complete in a thread pool 0.39 us
Time for a task to complete in the same thread 0.08 us

En liten fotnote om hva "dyrt" egentlig er. Eksempel på tid brukt for å gjøre minimale oppgaver:

Fra Stack Overflow:

http://stackoverflow.com/questions/5483047/why-is-creating-a-thread-said-to-be-expensive

ExecutorService og Executors

ExecutorService er et grensesnitt for klasser som kan ta imot jobber og utføre dem.

Executors er en hjelpeklasse for å lage forskjellige varianter av ExecutorService.

ExecutorService es = Executors.newCachedThreadPool();
es.execute(() -> System.out.println("Hello world"));

Executors - de viktigste

ExecutorService es = Executors.newCachedThreadPool();

[...] creates new threads as needed, but will reuse previously constructed threads when they are available.

[...] reuses a fixed number of threads operating off a shared unbounded queue.

ExecutorService es = Executors.newFixedThreadPool(n);

ExecutorService es = Executors.newSingleThreadExecutor();

ExecutorService es = Executors.newWorkStealingPool(n);

[...] maintains enough threads to support the given parallelism level, and may use multiple queues to reduce contention.

Når er programmet ferdig?

ExecutorService es = Executors.newCachedThreadPool();
es.execute(() -> System.out.println("Hello world"));
// ...
es.shutdown();

En "vanlig" ExecutorService vil holde programmet i live helt til du stopper den.

Etter shutdown() vil den ikke ta imot flere oppgaver, men vil gjøre ferdig de den allerede har.

ForkJoinPool

ForkJoinPool er en spesialisert ExecutorService bl.a. for rekursiv parallellisering, men kan brukes til vanlige oppgaver også.

ForkJoinPool.commonPool() gir tilgang til en instans med samme "parallellitet" som antall kjerner.

Bruker work-stealing og daemon-tråder (tråder som ikke holder igjen programmet fra å avslutte)

Executors.newWorkStealingPool(n) bruker en ForkJoinPool på innsiden, så vil heller ikke holde igjen programmet fra å avslutte.

Postkontor

Trix-oppgave 8.3,

en liten oppfriskning

Postkontor.leverPost(post)

Putt post inn i en kø, vent hvis det ikke er plass.

Postkontor.hentPost()

Hent post, vent hvis det ikke er noe.

Postkontor m/wait-notify

public class Postkontor {
    private final int maksPost = 10;
    private Post[] postHylle = new Post[maksPost];
    private int antallPost = 0;

    public synchronized void leverPost(Post post) {
        while (antallPost >= maksPost) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        for (int i = 0; i < maksPost; i++) {
            if (postHylle[i] == null) {
                postHylle[i] = post;
                antallPost++;
                notifyAll();
                return;
            }
        }
        throw new IllegalStateException("Ikke plass selv om vi trodde det!");
    }

    public synchronized Post hentPost() {
        while (antallPost <= 0) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        for (int i = 0; i < maksPost; i++) {
            if (postHylle[i] != null) {
                Post ret = postHylle[i];
                postHylle[i] = null;
                antallPost--;
                notifyAll();
                return ret;
            }
        }
        throw new IllegalStateException("Ikke post selv om vi trodde det!");
    }
}

Postkontor

Alt dette er egentlig bare en BlockingQueue<Post>. En kø som blokkerer når det man prøver å gjøre ikke går.

Postkontor

public class Postkontor {
    private final int maksPost = 10;
    private BlockingQueue<Post> queue = new LinkedBlockingQueue<>(maksPost);

    public void leverPost(Post post) {
        try {
            queue.put(post);
        } catch (InterruptedException e) {
            // Å sende feilmeldingen oppover hadde nok vært bedre,
            // men for å matche signaturen som var:
            throw new RuntimeException(e);
        }
    }

    public Post hentPost() {
        try {
            return queue.take();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

Postkontor m/mottaker

public class Postkontor {
    private final int maksPost = 10;
    private Map<String, BlockingQueue<Post>> queues = new ConcurrentHashMap<>();
    private Semaphore plasser = new Semaphore(maksPost);

    public BlockingQueue<Post> getQueue(String key) {
        return queues.computeIfAbsent(key, k -> new LinkedBlockingQueue<>());
    }

    public void leverPost(Post post) {
        try {
            plasser.acquire();
            getQueue(post.getMottaker()).put(post);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public Post hentPost(String mottaker) {
        try {
            Post ret = getQueue(mottaker).take();
            plasser.release();
            return ret;
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

Postkontor m/mottaker

public class Postkontor { // utdrag
    private final int maksPost = 10;
    private Semaphore plasser = new Semaphore(maksPost);

    public void leverPost(Post post) {
            plasser.acquire(); // plasser--, blokker hvis 0
    }

    public Post hentPost(String mottaker) {
            plasser.release(); // plasser++
    }
}

For å fortsatt ha ti plasser totalt bruker vi Semaphore, som er et tall vi kan telle opp og ned, og hvis vi prøver å telle under 0, blokkerer vi til noen teller opp.

Postkontor m/mottaker

public class Postkontor { // utdrag
    private Map<String, BlockingQueue<Post>> queues = new ConcurrentHashMap<>();

    public BlockingQueue<Post> getQueue(String key) {
        return queues.computeIfAbsent(key, k -> new LinkedBlockingQueue<>());
    }

    public void leverPost(Post post) {
        getQueue(post.getMottaker()).put(post);
    }

    public Post hentPost(String mottaker) {
        return getQueue(mottaker).take();
    }
}

computeIfAbsent gjør atomisk: henting og eventuell insetting ved manglende element.

Selv om ConcurrentHashMap er trygg må vi fortsatt passe på hva vi lagrer i den og hvordan vi bruker den.

CompletableFuture

CompletableFuture.runAsync(() -> {
    System.out.println("Hello world");
});

Lagt til i Java 8 og er på en gang veldig enkel og superkomplisert.

Du kan enkelt kjøre noe i en bakgrunnstråd:

CompletableFuture

CompletableFuture.supplyAsync(() -> {
    return "Hello";
}).thenAcceptBothAsync(CompletableFuture.supplyAsync(() -> {
    return " world";
}), (a, b) -> {
    System.out.println(a + b);
});

Det som gjør ting komplisert (og nyttig) er at du kan kombinere oppgaver: