• Пока задача не завершилась – все ждут
• Память – монопольное использование
• Ввод-вывод – монопольное использование

• Простой ресурсов
• Большое время отклика

• Память – разделяемая, изолированная
• Ввод-вывод – переключение задач
• Управление заданиями – монитор

• Увеличение загрузки ресурсов
• Большое время отклика

• Память – разделяемая, изолированная
• Прерывание – переключение задач
• Ввод-вывод – разделяемый

• Уменьшение времени отклика

• Память – общая
• Прерывание – переключение потоков
• Ввод-вывод – разделяемый

• Уменьшение времени отклика
• 1990-е годы

• Синхронизация
• Обмен сообщениями

// Матрицы размера n×n
double[][] a, b, c;
for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
        c[i][j] = 0;
        for (int k = 0; k < n; k++) {
            c[i][j] += a[i][k] * b[k][j];
        }
    }
}

// Матрицы размера n×n
/*shared*/ double[][] a, b, c;
for (int i = 0; i < n; i++) {     // Параллельно
    for (int j = 0; j < n; j++) { // Параллельно
        c[i][j] = 0;
        for (int k = 0; k < n; k++) {
            c[i][j] += a[i][k] * b[k][j];
        }
    }
}

• worker[i] {
      double[]   a; // a[i][⋅]
      double[][] b; // b[⋅][⋅]
      double[]   c; // c[i][⋅]
      receive a, b from coordinator;
      for (int j = 0; j < n; j++) {
          c[j] = 0;
          for (int k = 0; k < n; k++) {
              c[j] += a[k] * b[k][j];
          }
      }
      send c to coordinator;
  }
  

• coordinator(int i) {
      double[][] a, b, c;
      for (int i = 0; i < n; i++) {
          send a[i], b to worker[i];
      }
      for (int i = 0; i < n; i++) {
          receive c[i] from worker[i];
      }
  }
  

• worker[i] {
      double[] a; // a[i][⋅]
      double[] b; // b[⋅][i]
      double[] c; //  c[i][⋅]
      receive a, b from coordinator;
      for (int j = 0; j < n; j++) {
          // Вычисление c[(i - j + n) % n]
          send b to worker[(i + 1) % n];
          receive b from worker[(i + n - 1) % n];
      }
      send c to coordinator;
  }
  

double integrate(double l, double r) {
    if (abs(area(l, m) + area(m, r) - area(l, r)) > ε) {
        return integrate(l, m) + integrate(m, r);
    } else {
        return area(l, m) + area(m, r);
    }
}
double area(double l, double r) {
    return (f(l) + f(r)) * (r - l) / 2;
}

double integrate(double l, double r) {
    double m = (l + r) / 2;
    double la = area(l, m);
    double ra = area(m, r);
    if (abs(la + ra - area(l, r)) > ε) {
        la = integrate(l, m); // Параллельно
        ra = integrate(m, r); // Параллельно
    }
    return la + ra;
}

〈statements〉

〈await(C) statements〉

/* shared */ int max = 0;
create worker[i] {
    if (max < a[i]) max = a[i];
}

/* shared */ int max = 0;
create worker[i] {
    〈if (max < a[i]) max = a[i];〉
}

/* shared */ int max = 0;
create worker[i] {
    if (max < a[i]) {
        〈if (max < a[i]) max = a[i];〉
    }
}

• Кооперативная
• Вытесняющая

• Безусловная (отсутствие условий)
• Слабая
• Сильная

• Поток исполнения
• Позволяет создавать потоки и производить операции с ними

• Сущность, которая может быть запущена
• public void run()

// Создание
Thread t = new Thread(() -> {
    System.out.println("Hello");
});
// Запуск
t.start();

• Thread.State getState()
• boolean isAlive()

• id – идентификатор потока
• name – имя потока
• priority – приоритет
  • MIN_PRIORITY, NORM_PRIORITY, MAX_PRIORITY
• daemon – поток-демон

• thread.join()

• thread.join(millis, nanos?)

• thread.interrupt()

• thread.isInterrupted()

• Thread.interrupted()

• На время
  • Thread.sleep(time)
• Позволить выполниться другим потокам
  • Кооперативная многозадачность
  • Thread.yield()

• Thread.currentThread()

• defaultUncaughtExceptionHandler

Runnable worker = run() -> {
    try {
        while (!Thread.interrupted()) {
            // Полезные действия
        }
    } catch (InterruptedException e) {
        // Поток заканчивает работу
    } finally {
        // Восстановление флага прерывания
        Thread.currentThread().interrupt();
    }
}