Nebenläufigkeit

In Java ist ein Thread ein Objekt der Klasse Thread. Ihm gibst du mit, was er tun soll, als Lambda; start() lässt ihn loslaufen, join() wartet, bis er fertig ist. Dieses Programm lässt zwei Threads je hunderttausendmal count++ ausführen:

int count = 0;

void main() throws InterruptedException {
    Thread a = new Thread(() -> { for (int i = 0; i < 100000; i++) count++; });
    Thread b = new Thread(() -> { for (int i = 0; i < 100000; i++) count++; });
    a.start();
    b.start();
    a.join();
    b.join();
    IO.println(count);
}

Dart hat keine Threads, die sich Variablen teilen. Ein Dart-Programm macht immer nur eins auf einmal. Trotzdem kann eine Erhöhung verloren gehen: an einem await. Dort hält eine async-Funktion an, bis etwas fertig ist, etwa das Speichern, und in der Zwischenzeit läuft anderer Code weiter. Diese Funktion zahlt Geld auf ein Konto ein und speichert dabei:

var balance = 0;

Future<void> save() => Future.delayed(const Duration(milliseconds: 10));

Future<void> deposit(int amount) async {
  final before = balance;
  await save();
  balance = before + amount;
}

Future.wait startet mehrere solche Aufrufe und wartet, bis alle fertig sind:

balance = 0;
await Future.wait([deposit(5), deposit(7)]);
print(balance);

Ein Lock heißt in Java oft einfach synchronized. Eine Methode mit diesem Wort kann immer nur ein Thread zugleich ausführen; jeder andere wartet, bis sie wieder frei ist. Das ist der Lock aus dem Widget, um die ganze Methode herum.

Damit nichts verloren geht, darf eine Einzahlung erst beginnen, wenn die vorige fertig ist. In einer Schleife mit await geht das: Jedes await deposit(…) wartet, bis diese Einzahlung gespeichert ist.

Die Überweisungen aus dem Widget sehen in Java so aus. synchronized (from) { … } nimmt den Lock des Objekts from und gibt ihn am Ende des Blocks wieder frei; jedes Objekt in Java hat so einen Lock. run lässt zwei Threads je times-mal überweisen, einen von x nach y, einen zurück:

class Account {
    final int id;
    int balance;

    Account(int id, int balance) {
        this.id = id;
        this.balance = balance;
    }
}

public class Bank {
    static void transfer(Account from, Account to, int amount) {
        synchronized (from) {
            synchronized (to) {
                from.balance -= amount;
                to.balance += amount;
            }
        }
    }

    static int run(int times) throws InterruptedException {
        Account x = new Account(1, 100);
        Account y = new Account(2, 100);
        Thread a = new Thread(() -> { for (int i = 0; i < times; i++) transfer(x, y, 1); });
        Thread b = new Thread(() -> { for (int i = 0; i < times; i++) transfer(y, x, 1); });
        a.start();
        b.start();
        a.join();
        b.join();
        return x.balance + y.balance;
    }

    static void main() throws InterruptedException {
        IO.println(run(100000));
    }
}

Für async-Code hat Dart keinen Lock, aber einen kann man aus Futures bauen. Diese Klasse merkt sich in _last, wann die zuletzt angemeldete Aktion fertig ist. synchronized hängt die nächste Aktion mit then dahinter: Sie beginnt erst, wenn die vorige fertig ist, auch wenn sie mit einem Fehler endet.

class Lock {
  Future<void> _last = Future.value();

  Future<T> synchronized<T>(Future<T> Function() action) {
    final result = _last.then((_) => action());
    _last = result.then((_) {}, onError: (_) {});
    return result;
  }
}

lock.synchronized(() => deposit(5)) meldet eine Einzahlung beim Lock an. Startest du mehrere so zugleich, kommt trotzdem eine nach der anderen an die Reihe.

Oft macht ein Thread etwas, das ein anderer weiterverarbeitet: Ein Thread liest Anfragen, ein anderer beantwortet sie. Dazwischen liegt ein Puffer mit Platz für ein paar Werte. Ist er voll, muss der eine warten; ist er leer, der andere. Eine Klasse, deren Methoden alle synchronized sind und die Threads so warten lässt, heißt Monitor.

Warten geht in Java mit wait(): Der Thread gibt den Lock des Objekts ab und schläft, bis ein anderer notifyAll() aufruft. Danach bekommt er den Lock zurück und prüft seine Bedingung noch einmal, darum steht wait() in einer while-Schleife:

public synchronized void put(int x) throws InterruptedException {
    while (count == items.length) {
        wait();
    }
    // … x hineinlegen …
    notifyAll();
}

Ein Isolate ist in Dart ein eigener Arbeiter mit eigenem Speicher. Isolates teilen keine Variablen; sie schicken einander nur Nachrichten. Darum kann zwischen ihnen auch keine Erhöhung verloren gehen. Und anders als async-Code laufen mehrere Isolates wirklich gleichzeitig, auf mehreren Kernen.

Isolate.run startet eine Funktion in einem neuen Isolate und gibt ihr Ergebnis als Future zurück. Diese Funktion zählt die Primzahlen von from bis vor to:

import 'dart:isolate';

int countPrimes(int from, int to) {
  var count = 0;
  for (var n = from; n < to; n++) {
    if (n < 2) continue;
    var prime = true;
    for (var d = 2; d * d <= n; d++) {
      if (n % d == 0) {
        prime = false;
        break;
      }
    }
    if (prime) count++;
  }
  return count;
}

await Isolate.run(() => countPrimes(0, 1000)) zählt dasselbe in einem eigenen Isolate.

Java hat so einen Puffer schon: ArrayBlockingQueue. Seine Methoden put und take warten genauso, wenn er voll oder leer ist. Im Alltag nimmst du ihn statt eines eigenen Monitors.

Mehr dazu

• Wikipedia: Tony Hoare
• Wikipedia: Quicksort
• theregister.com
• infoq.com
• merton.ox.ac.uk
• cs.ox.ac.uk
• Wikipedia: Monitor (synchronization)

Tony Hoare (1934–2026), britischer Informatiker. Quick Sort erfand er 1959 als Austauschstudent in Moskau: Er sollte ein Programm schreiben, das Russisch übersetzt, und musste dafür die Wörter eines Satzes sortieren.

1965 baute er in eine Programmiersprache den Wert null ein, »weil es so einfach war«. Später nannte er ihn seinen »Milliarden-Dollar-Fehler«: Meldungen wie undefined method … for nil in Ruby stammen von dieser Idee.

Anfang der 1970er Jahre entwickelte er mit Per Brinch Hansen den Monitor, der verhindert, dass Threads zugleich an die Daten eines gemeinsamen Objekts gehen.

Foto: Rama, 2011, CC BY-SA 2.0 fr, zugeschnitten (Wikimedia Commons)