slides/day8.html

<!doctype html>
<html lang="en">
	<head>
		<meta charset="utf-8">
		<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">

		<title>Акторы Akka</title>

		<link rel="stylesheet" href="css/reveal.css">
		<link rel="stylesheet" href="css/theme/moon.css">

		<!-- Theme used for syntax highlighting of code -->
		<link rel="stylesheet" href="lib/css/zenburn.css">

		<!-- Printing and PDF exports -->
		<script>
			var link = document.createElement( 'link' );
			link.rel = 'stylesheet';
			link.type = 'text/css';
			link.href = window.location.search.match( /print-pdf/gi ) ? 'css/print/pdf.css' : 'css/print/paper.css';
			document.getElementsByTagName( 'head' )[0].appendChild( link );
		</script>
	</head>

	<body>

		<div class="reveal">

			<!-- Any section element inside of this container is displayed as a slide -->
			<div class="slides">
				<section>
					<h3>Акторы Akka</h3>
					<p><small>Страничка курса: <a href="https://maxcom.github.io/scala-course-2022/">https://maxcom.github.io/scala-course-2022/</small></a>
				</section>

				<section>
					<h2>План</h2>
                                        <ol>
        	                                <li>Актор — асинхронный объект.</li>
						<li>Диспетчеры.</li>
						<li>Future и акторы</li>
						<li>Stash</li>
						<li>Таймеры и deadline
					 	<li>Обработка исключительных ситуаций.</li>
						<li>Death watch и death pact
					</ol>
				</section>

				<section>
					<h2>Akka и акторы</h2>
				</section>

				<section>
					<p>Akka - набор библиотек.<br> Сегодня рассмотрим ядро - акторы Akka.
				</section>

				<section>
					<p>Модель акторов - 1973 год,<br>
					использовалась как модель для описания параллельных систем.
				</section>

				<section>
					<p>Позже стала применяться в качестве базы для
					практических реализаций.
				</section>

				<section>
					<p>Популярность получила благодаря Erlang:<br>
					языку программирования и платформе,
					разработанной Ericsson (1987 г.)
				</section>

				<section>
					<p>Erlang динамический + другая модель многопоточности
					<p>Дальше будем говорить про реализацию модели
					в библиотеке <a target="_blank" href="https://akka.io/">Akka</a>.
				</section>

				<section>
					<p>Подключаем в проект: build.sbt

					<pre><code class="scala">
libraryDependencies += 
  "com.typesafe.akka" %% "akka-actor-typed" % "2.6.19"
libraryDependencies += // или другой backend Slf4j
  "ch.qos.logback" % "logback-classic" % "1.2.11"
					</code></pre>
				</section>

				<section>
					<p>Два варианта API:
					<ul>
						<li>«Классический» - копия Erlang, без типов
						<li>«Typed» - типы и много улучшений
					</ul>
					<p><small>"Классические" акторы в лекции 2018 года.</small>
				</section>

				<section>
					<p>Правильные import'ы:

					<pre><code class="scala">
import akka.actor.typed.scaladsl.Behaviors
import akka.actor.typed.{ActorRef, Behavior}
					</code></pre>
					<p><small>Не перепутайте с javadsl и "классическими" api</small>
				</section>

				<section>
					<p>Разделяемое изменяемое состояние + параллелизм = проблемы<p>
					<div class="fragment">
					<p><s>Разделяемое</s> изменяемое состояние + параллелизм = 
					«Share nothing» архитектура</p>
					</div>
				</section>

				<section>
					<p>Актор — асинхронный объект</p>

					<ul>
						<li class="fragment">Приватное изменяемое состояние
						<li class="fragment">Mailbox - входящая очередь сообщений,<br>
						вместо явного вызова методов
						<li class="fragment">Логика обработки сообщений (behavior),<br>
						вместо реализации методов
						<li class="fragment">Логика обработки ошибок
					</ul>
				</section>

				<section>
					<table>
						<thead>
							<tr>
								<th></th><th>Объект</th> <th>Актор</th>
							</tr>

							<tr class="fragment">
								<td>Вызов</td>
								<td>counter.incr(n)</td>
								<td>counter ! Incr(n)</td>

							</tr>
							<tr class="fragment">
								<td>Запрос</td>
								<td>counter.get()<br>⇒ Int</td>
								<td><s>counter ? Get</s><br>
								counter.ask(Get)<br>⇒ Future[Int]</td>
							</tr>
						</thead>
					</table>
				</section>

				<section>
					<p>В ООП логика моделируется взаимодействием объектов.

					<p class="fragment">В модели акторов - взаимодействием акторов путем 
					обмена сообщениями.
				</section>

				<section>
					<p>В ООП методы можно вызывать из разных потоков.

					<p class="fragment">Потокобезопасность?

					<ul>
						<li class="fragment">реализована при помощи блокировок, atomic и т.п.
						<li class="fragment">отсутствует, т.е. перекладывается на пользователя
					</ul>
				</section>

				<section>
					<p>У актора обработка сообщений строго последовательна.

					<p class="fragment">Разные акторы работают независимо в разных потоках.

					<p class="fragment">Общение двух акторов последовательно<br> (очередь не
					перемешивается).
				</section>

				<section>
					<p>Пример: актор счетчика
					<pre><code class="scala">
object Counter {
  sealed trait Protocol

  case class Incr(n: Long) extends Protocol
  case class Get(replyto: ActorRef[Long]) extends Protocol

  def behavior: Behavior[Protocol] = ???
}					
					</code></pre>
				</section>

				<section>
					<p>Актор с изменяемым состоянием
					<pre><code class="scala">
def behavior: Behavior[Protocol] = Behaviors.setup { ctx =&gt;
  // изменяемое состояние
  var value: Long = 0

  Behaviors.receiveMessage {
    case Incr(n) =&gt;
      value += n
      Behaviors.same // не меняем behavior
    case Get(replyto) =&gt;
      replyto ! value
      Behaviors.same
  }
}
					</code></pre>
				</section>

				<section>
					<p>"Immutable" актор
					<pre><code class="scala">
private def counter(value: Long): Behavior[Protocol] = 
  Behaviors.receiveMessage {
    case Incr(n) =&gt;
      counter(value + n) // новый behavior
    case Get(replyto) =&gt;
      replyto ! value
      Behaviors.same
}

def behavior: Behavior[Protocol] = counter(0)
					</code></pre>
				</section>
				
				<section>
					<p>"Immutable"  предпочтительнее, но не всегда эффективен
					<p><small>mutable.Queue и многие другие структуры эффективнее immutable</small>
				</section>

				<section>
					<p>Запускаем Akka
					<pre><code class="scala">
object Main extends App {
  val system: ActorSystem[Counter.Protocol] = // корневой актор
    ActorSystem(Counter.behavior, "counter") // "counter" - имя

  // оправка в system это отправка корневому актору
  system ! Counter.Incr(1)

  system.terminate()
}
					</code></pre>
					<p><small>запуск множества акторов будет дальше</small>
				</section>

				<section>
					<p>Используем Ask
					<pre><code class="scala">import akka.actor.typed.scaladsl.AskPattern._

object Main extends App {
  implicit val system: ActorSystem[Counter.Protocol] = ???
// ^^^^^^ ask создаем временные акторы

  system ! Counter.Incr(1)

  implicit val timeout: Timeout = 10.seconds

  val result: Future[Long] = system ? Counter.Get
  println(Await.result(result, 1.minutes))

  system.terminate()
}
					</code></pre>
				</section>

				<section>
					<p>Приватное состояние - не только переменные.

					<p class="fragment">Актор может скрывать за собой внешние сущности:
					<ul>
						<li class="fragment">RandomAccessFile (seek/read). 
						<li class="fragment">данные во внешнем хранилище.
						<li class="fragment">и др.
					</ul>
				</section>

				<section>
					<p>Актор должен иметь приватное состояние
					<p>Исключение - отказоустойчивость или балансировка
					нагрузки
				</section>

				<section>
					<p>Что можно отправлять актору?

					<ul>
						<li class="fragment">Неизменяемые данные
						<li class="fragment">Ссылки на акторы - ActorRef
					</ul>

					<p class="fragment">Изменяемые объекты посылать нельзя!
				</section>

				<section>
					<p>Можно ли посылать функции?

					<ul>
						<li class="fragment">Можно, потому что в функции тоже неизменяемые
						<li class="fragment">Нельзя, если в замыкании мутабельные структуры.<br>
						<span class="fragment">И еще это сомнительно с точки зрения модели.</span>
					</ul>
				</section>

				<section>
					<p>Можно ли посылать внешние объекты, вроде коннектов к БД, сокетов, т.п.?

					<ul>
						<li class="fragment">Нельзя, это нарушение модели
						<li class="fragment">Можно, когда понимаем, что делаем и зачем.<br>
						<span class="fragment">Так делают на "границе" между акторами и внешним миром.</span>
					</ul>
				</section>

				<section>
					<p>Пример актора: классификатор с обучением

					<p class="fragment">Один актор на классификацию и обучение - просто, но не эффективно
					<p class="fragment">Актор для обучения, get запрос для модели<br>
					(нужна immutable модель или функция копирования)
				</section>

				<section>
					<h3>Location transparency</h3>

					<p>Акторы могут быть расположены в разных виртуальных машинах и на разных серверах.
				</section>

				<section>
					<p>Взаимодействие акторов по сети не похоже на RPC (Remote Procedure Call).

					<ul>
						<li class="fragment">Классический RPC — удаленные вызовы подобны локальным
						<li class="fragment">Акторы — локальные «вызовы» подобны удаленным
					</ul>
				</section>

				<section>
					<h3>Дочерние акторы и SpawnProtocol</h3>
					<ul>
						<li>Актор может запустить дочерние акторы
<pre><code class="scala">context.spawn(HelloWorld(), "greeter")</code></pre>
						(об этом позже)
						<li>На верхнем уровне - SpawnProtocol
					</ul>
				</section>

				<section>
					<p>SpawnProtocol - актор, порождающий акторы

					<pre><code class="scala">
implicit val system: ActorSystem[SpawnProtocol.Command] = 
  ActorSystem(SpawnProtocol(), "root")

val counterF: Future[ActorRef[Counter.Protocol]] =
  system.ask(Spawn(Counter.behavior, "counter", Props.empty, _))
// _ для replyTo, иногда нужно явно указать тип
					</code></pre>
				</section>

				<section>
					<h3>Диспетчеры</h3>
					<ul>
						<li>Runtime для акторов</li>
						<li>Работают поверх Executor'ов</li>
						<li>Рабочие треды — разделяемый ресурс</li>
					</ul>
				</section>

				<section>
					<h3>Диспетчеры — проблемы</h3>
					<ul>
						<li>Не все акторы одинаковы</li>
						<li>Акторы с долгими задачами могут занять все треды</li>
						<li>Диалоги с большим количеством сообщений занимают диспетчер</li>
						<li>В Akka 2.6 сама Akka использует internal dispatcher	
					</ul>
				</section>

				<section>
					<h3>Диспетчеры под задачи</h3>
					<ul>
						<li>Интерактивные задачи vs фоновая пакетная обработка.
						<li class="fragment">Блокирующиеся вызовы (JDBC, файловый ввод-вывод, долгие вычисления).
						<li class="fragment">Свой «отсек» на каждую подсистему (bulkheading).
						<li class="fragment">Своя JVM и свой сервер на каждую подсистему (Akka Remote / Cluster).
					</ul>
					<p class="fragment">Факт: «Титаник» утонул из-за плохого разделения на отсеки.</p>
				</section>

				<section>
					<p>Указываем диспетчер при создании актора
					<pre><code class="scala">
context.spawn(yourBehavior, "BlockingDispatcher", 
  DispatcherSelector.blocking())
context.spawn(yourBehavior, "DispatcherFromConfig", 
  DispatcherSelector.fromConfig("your-dispatcher"))
					</code></pre>
				</section>

				<section>
					<p>application.conf</p>
<pre><code>
default-blocking-io-dispatcher {
  type = "Dispatcher"
  executor = "thread-pool-executor"
  throughput = 1 // переключение после N сообщений

  thread-pool-executor {
    fixed-pool-size = 16
  }
}
</code></pre>
				</section>

                                <section>
                                        <h2>Конец первой части</h2>
                                </section>

				<section>
					<h3>Работа с Future в акторе</h3>
					<p>Обращаемся к асинхронным API в акторе</p>
				</section>

				<section>
					<p>Пример
					<pre><code class="scala">object CacheActor {
  trait Protocol

  // отдать из кеша
  case class Get(replyto: ActorRef[String]) 
    extends Protocol

  // обновить кеш и отдать новое
  case class RefreshAndGet(replyto: ActorRef[String]) 
    extends Protocol

  def behavior(source: =&gt; Future[String]): Behavior[Protocol] = 
    ???
}</code></pre>
				</section>

				<section>
					<pre><code class="scala">def behavior(source: =&gt; Future[String]): Behavior[Protocol] = 
  Behaviors.setup { ctx =&gt;
    var current = "undefined"

    Behaviors.receiveMessage {
      case Get(replyto) =&gt;
        replyto ! current
        Behaviors.same
      case RefreshAndGet(replyto) =&gt;
        import ctx.executionContext // для onComplete
        source.onComplete(???)
        Behaviors.same
    }
  }</code></pre>
				</section>

				<section>
					<p>Можно ли из onComplete менять state актора?
				</section>

				<section>
  					<p>добавляем приватный Refresh(value)
					<pre><code class="scala">case RefreshAndGet(replyto) =&gt;
  import ctx.executionContext

  source.onComplete {
    case Success(v) =&gt;
      ctx.self ! Refresh(v)
      replyto ! v 
      // или Refresh(v, replyto) и отправка после Refresh
    case Failure(ex) =&gt; // handle failure
  }

  Behaviors.same
case Refresh(value) =&gt;
  current = value
  Behaviors.same</code></pre>
				</section>

				<section>
					<p>pipeTo: посылаем результат себе самому
					<pre><code class="scala">// преобразуем результат в протокол
ctx.pipeToSelf(source) {
  case Success(v) =&gt;
    Refresh(v)
  case Failure(ex) =&gt;
    RefreshFailed(ex)
}
					</code></pre>
				</section>

				<section>
					<p>AskPattern внутри актора: "context.ask"
					<pre><code class="scala">// преобразуем результат в протокол
ctx.ask(sourceActor, Get) {
  case Success(v) =&gt;
    Refresh(v)
  case Failure(ex) =&gt;
    RefreshFailed(ex)
}
					</code></pre>
				</section>

				<section>
					<h3>Stash</h3>
					Механизм, позволяющий временно отложить сообщения
				</section>

				<section>
					<p>Пример: откладываем Get до окончания Refresh

					<p>В синхронном варианте проблемы нет.
				</section>

				<section>
					<p>Задаем stash и state машину
					<pre><code class="scala"> 
def behavior(source: =&gt; Future[String]): Behavior[Protocol] = 
  Behaviors.setup { ctx =&gt;
    var current = "undefined"

    Behaviors.withStash(capacity = 1000) { stash =&gt;
      def working: Behavior[Protocol] = ??? // ждем запрос
      def waiting: Behavior[Protocol] = ??? // ждем refresh

      working
    }
  }
					</code></pre>
				</section>

				<section>
					<p>обработка запроса
					<pre><code class="scala">def working: Behavior[Protocol] = 
  Behaviors.receiveMessagePartial {
    case Get(replyto) =&gt;
      replyto ! current
      Behaviors.same
    case RefreshAndGet(replyto) =&gt;
      ctx.pipeToSelf(source) {
        case Success(v) =&gt;
          Refresh(v)
        case Failure(ex) =&gt;
          RefreshFailed(ex)
      }

      waiting // переход в waiting
  }</code></pre>
				</section>

				<section>
					<p>ожидание Refresh
					<pre><code class="scala"> 
def waiting: Behavior[Protocol] = Behaviors.receiveMessage {
  case Refresh(value) =&gt;
    current = value
    stash.unstashAll(working)
  case RefreshFailed(ex) =&gt; // нужна обработка
    stash.unstashAll(working)
  case other =&gt;
    // помним, что stash может переполниться
    stash.stash(other)
    Behaviors.same
}
					</code></pre>
				</section>

				<section>
					<p>Какой размер Stash?

					<p class=fragment><s>Сколько не жалко</s>
					<p class=fragment>Сколько имеет смысл накапливать
				</section>

				<section>
					<p>Число операций O(N<sup>2</sup>)<br>
					N - размер Stash
					<p>Иногда эффективнее накапливать<br> запросы
					в другой структуре
				</section>

				<section>
					<h3>Таймеры и Deadline</h3>
				</section>

				<section>
					Как реализовать таймауты в акторах?
				</section>

				<section>
					<p>Deadline - точка во времени

					<pre><code class="scala">
import scala.concurrent.duration._

val deadline: Deadline = 5.minutes.fromNow
					</code></pre>
				</section>

				<section>
					<ul>
						<li>Использует монотонные часы:<br>
						не зависят от системного времени
						<li class="fragment">Можно передавать внутри JVM,<br>
						нельзя по сети и на диск</li>
					</ul>
				</section>

				<section>
					<pre><code class="scala">
deadline.hasTimeLeft() // проверки
deadline.isOverdue()

// величина таймаута, например для ask
val timeout: Duration = deadline.timeLeft
					</code></pre>
					<p>еще их можно использовать для вычисления длительности операций
				</section>

				<section>
					<p>Совет: в REST передавайте таймаут в заголовке
					<p class=fragment>Плохая ситуация: клиент делает retry раньше, чем заканчивается обработка
				</section>

				<section>
					<p>Таймеры
					<pre><code class="scala">
Behaviors.withTimers { timers =&gt;
  // key для уникальности таймера
  // msg - отправляемое сообщение
  timers.startSingleTimer(key = CheckTimeout, 
                          msg = CheckTimeout, 
			  1.minute)

  timers.startPeriodicTimer(key = Tick, msg = Tick, 1.minute)
  
  timers.cancel(Tick)
  timers.cancelAll()
					</code></pre>
				</section>

				<section>
					<p>Зачем?

					<ul>
						<li>Обработка таймаутов
						<li>Сборка batch
						<li>Периодическое обновление, очистка
						<li>Печать статистики работы
					</ul>
				</section>

				<section>
					<p>Receive Timeout - реакция на отсутствие сообщений

					<p class="fragment">Защитный механизм для коротокоживущих акторов

					<pre class="fragment"><code class="scala">ctx.setReceiveTimeout(5.minutes, ReceiveTimeout)

// отправляет ReceiveTimeout при отсутствии активности
					</code></pre>

					<p class="fragment"><small>Игнорирует сообщения, расширяющие NotInfluenceReceiveTimeout</small>
				</section>

				<section>
					<h3>Обработка исключительных ситуаций</h3>
					<p>В ООП и ФП ошибки обрабатывает тот,<br> кто вызывает функцию.
					<p>Правильно ли это?
				</section>

				<section>
					<p>Пример: виды ошибок в автомате с газировкой:
					<ul>
						<li>«Недостаточно средств», «закончилась кола» — покупателю
						<li>NullPointerException, CocaColaJamException — владельцу автомата (супервизору)
					</ul>
				</section>

				<section>
					<h3>Пример: драйвер базы данных</h3>
					<ul>
						<li>Дублирование первичного ключа, нарушение foreign key — пользователю драйвера</li>
						<li>«БД перезагружается», «Соединение разорвано» — супервизору</li>
					</ul>
				</section>

				<section>
					<p>Родитель - супервизор дочернего актора
					<p>DriverActor → ConnectionActor → TransactionActor
				</section>

				<section>
					<h3>Стратегии супервизора</h3>
					<ul>
						<li><strong>resume</strong> — игнорируем ошибку,<br>
						сообщение теряется
						<li class="fragment"><strong>restart</strong> — незаметный для клиента перезапуск,<br>
						сообщение теряется, пересоздается state
						<li class="fragment"><strong>restartWithBackoff</strong> — перезапуск с задержкой
						<li class="fragment"><strong>stop</strong> — остановка
					</ul>
				</section>

				<section>
					<p>По умолчанию: остановка.<br>
					Не забываем про это!!!
				</section>

				<section>
					При остановке и рестарте актора все его дочерние акторы останавливаются
				</section>

				<section>
					<p>Задаем Supervisor
					<pre><code class="scala">
def behavior(source: =&gt; Future[String]): Behavior[Protocol] =
  Behaviors
    .supervise[Protocol](...)
    .onFailure[Throwable](SupervisorStrategy.restart)
					</code></pre>
					<p>разная стратегия для разных исключений
				</section>

				<section>
					<p>Пример: ConnectionActor</p>
					<pre><code class=scala>
Behaviors
  .supervise[Protocol](...)
  .onFailure[ConnectionResetException]
    (SupervisorStrategy.restartWithBackoff(
        minBackoff = 100 millis,
        maxBackoff = 30 seconds,
        randomFactor = 0.2))
  .onFailure[DatabaseWasDeletedException]
    (SupervisorStrategy.stop)
						</code></pre>
				</section>

				<section>
					<h3>Death pact &amp; death watch</h3>
					<p>Пример: один запрос – три иерархии.
					<img src="service.svg">
				</section>

				<section>
					<p>Ожидание остановки актора:</p>
					<pre><code class="scala">
context.watch(anotherActorRef)
					</code></pre>
					<p>Ловим сообщение Terminated(actorRef)
					<pre><code class="scala">
.receiveMessage {
  ...
}.receiveSignal {
  case (ctx, Terminated(actor)) =&gt;
    Behaviors.same
} // другие сигналы например: PostStop, PreRestart
	</code></pre>
				</section>

				<section>
					<p>Не обработали: работает «death pact» — 
					останавливаемся вместе (DeathPactException).</p>
				</section>

				<section>
					<p>В следующий раз:
					<ul>
						<li>Гарантии доставки сообщений
						<li>CircuitBreaker
						<li>Back pressure
						<li>Роутеры
					</ul>
				</section>

				<section>
					<p>Напоминаю:
					<ul>
						<li>Страничка курса: <a href="https://maxcom.github.io/scala-course-2022/">https://maxcom.github.io/scala-course-2022/</a>
					</ul>
				</section>
			</div>

		</div>

		<script src="lib/js/head.min.js"></script>
		<script src="js/reveal.js"></script>

		<script>
			// More info about config & dependencies:
			// - https://github.com/hakimel/reveal.js#configuration
			// - https://github.com/hakimel/reveal.js#dependencies
			Reveal.initialize({
                                controls: true,
                                progress: true,
                                history: true,
                                center: true,

                                transition: 'slide', // none/fade/slide/convex/concave/zoom

				dependencies: [
					{ src: 'plugin/markdown/marked.js' },
					{ src: 'plugin/markdown/markdown.js' },
					{ src: 'plugin/notes/notes.js', async: true },
					{ src: 'plugin/highlight/highlight.js', async: true, callback: function() { hljs.initHighlightingOnLoad(); } }
				]
			});
		</script>

	</body>
</html>