Elixir: Состояние процесса

В прошлом упражнении мы создали процесс-калькулятор, который только обрабатывает входящие запросы, не храня никакого состояния. Но как его сохранить? Основная идея процесса, который обрабатывает более одного сообщения за раз, это вызов рекурсивной функции, которая продолжит основной цикл обработки сообщений. Рассмотрим пример с процессом-счетчиком:

defmodule Counter do
  def init(parent, initial_state \\ 0) do
    process(parent, initial_state)
  end

  defp process(parent, state) do
    receive do
      :inc ->
        new_state = state + 1
        send(parent, {:ok, new_state})
        process(parent, new_state)

      :dec ->
        new_state = state - 1
        send(parent, {:ok, new_state})
        process(parent, new_state)

      :current ->
        send(parent, {:ok, state})
        process(parent, state)

      :reset ->
        send(parent, {:ok, 0})
        process(parent, 0)
    end
  end
end

В процессе-счетчике мы вынесли функцию запуска процесса, запомнили процесс-родитель и инициализировали состояние процесса-счетчика нулем. Затем при обработке сообщения изменяется состояние процесса, которое передается дальше в рекурсивный вызов функции process. Теперь запустим счетчик и проверим его работу:

Важно, что идентификатор родительского процесса мы передаем снаружи, так как вызов self() внутри модуля вернет иной идентификатор.

parent = self()
counter = spawn(fn -> Counter.init(parent) end)

send(counter, :current)
# для просмотра почтового ящика родительского процесса
# далее по коду будет подразумеваться, что эта строчка кода
# будет вызываться после каждой отправки сообщения другому процессу
Process.info(parent, :messages)
# => {:messages, [ok: 0]}

send(counter, :inc)
# => {:ok, 1}
send(counter, :inc)
# => {:ok, 2}

send(counter, :dec)
# => {:ok, 1}

send(counter, :inc)
# => {:ok, 2}

send(counter, :reset)
# => {:ok, 0}

send(counter, :dec)
# => {:ok, -1}

Важно заметить, что каждый процесс хранит свое состояние отдельно от других процессов:

parent = self()
first_counter = spawn(fn -> Counter.init(parent) end)
second_counter = spawn(fn -> Counter.init(parent) end)

send(first_counter, :inc)
send(first_counter, :inc)
send(first_counter, :inc)

send(second_counter, :dec)
send(second_counter, :dec)

send(first_counter, :current)
# => {:ok, 3}

send(second_counter, :current)
# => {:ok, -2}

Состояние не обязательно выражается числом, в него можно складывать что-угодно, начиная от чисел и заканчивая словарем со ссылками на другие процессы, к примеру.

Задание

В этот раз создайте процесс кеш-сервер, который хранит в состоянии словарь. Напишите функцию init, которая принимает родительский процесс и начальное состояние (как в примерах выше). Затем добавьте обработку следующих сообщений:

  • :put положить по переданному ключу key значение value в состояние кеш-сервера, возвращает кортеж {:ok, value};
  • :get достать из состояния процесса значение по переданному ключу, при отсутствии значения вернуть кортеж {:error, :not_found};
  • :drop убрать из состояния процесса переданный ключ;
  • :exit перестать обрабатывать входящие сообщения кеш-сервером, возвращает кортеж {:ok, :exited};
  • а еще добавьте обработку невалидных сообщений, чтобы процесс не ломался, если ему передать что-то не то (вернуть кортеж {:error, :unrecognized_operation}).
parent = self()
cache_server = spawn(fn -> CacheServer.init(parent) end)

send(cache_server, {:put, {:hello, "world"}})
# => {:ok, "world"}

send(cache_server, {:get, {:hello}})
# => {:ok, "world"}

send(cache_server, {:get, {:some}})
# => {:error, :not_found})

send(cache_server, {:drop, {:hello}})
# => {:ok, :hello}

send(cache_server, {:get, {:hello}})
# => {:error, :not_found})

send(cache_server, {:something, {1, 2, 3}})
# => {:error, :unrecognized_operation}
Process.alive?(cache_server)
# => true

send(cache_server, :boom)
# => {:error, :unrecognized_operation}
Process.alive?(cache_server)
# => true

send(cache_server, {:exit})
# => {:ok, :exited}
Process.alive?(cache_server)
# => false
Как с вами связаться? 🙃

Команда проекта находится в телеграм-сообществе по ссылке https://ttttt.me/HexletLearningBot. Там можно задать любой вопрос и повлиять на проект

Упражнение не проходит проверку — что делать? 😶

Если вы зашли в тупик, то самое время поговорить с нашим асситентом Тота во вкладке "Обсуждение". Как правильно задать вопрос:

В моей среде код работает, а здесь нет 🤨

Тесты устроены таким образом, что они проверяют решение разными способами и на разных данных. Часто решение работает с одними входными данными, но не работает с другими. Чтобы разобраться с этим моментом, изучите вкладку «Тесты» и внимательно посмотрите на вывод ошибок, в котором есть подсказки.

Мой код отличается от решения учителя 🤔

Это нормально 🙆, в программировании одну задачу можно выполнить множеством способов. Если ваш код прошел проверку, то он соответствует условиям задачи. В редких случаях бывает, что решение подогнано под тесты, но это видно сразу.

Прочитал урок — ничего не понятно 🙄

Создавать обучающие материалы, понятные для всех без исключения, довольно сложно. Мы очень стараемся, но всегда есть что улучшать. Если вы встретили материал, который вам непонятен, опишите проблему в обратной связи нашего сообщества

Нашли ошибку? Есть что добавить? Пулреквесты приветствуются

Привет! Я Тота и моя задача помочь в обучении. Чтобы активировать меня, нужно зарегистрироваться или залогиниться, если у вас уже есть аккаунт

Loading...

Ваше упражнение проверяется по этим тестам

1defmodule Test do
2  use ExUnit.Case
3
4  describe "cache server work" do
5    test "put" do
6      parent = self()
7      cache_server = spawn(fn -> CacheServer.init(parent) end)
8
9      send(cache_server, {:put, {:hello, "world"}})
10      assert_receive({:ok, "world"})
11      assert Process.alive?(cache_server)
12
13      send(cache_server, {:put, {:key, "value"}})
14      assert_receive({:ok, "value"})
15      assert Process.alive?(cache_server)
16    end
17
18    test "get" do
19      parent = self()
20      cache_server = spawn(fn -> CacheServer.init(parent) end)
21      send(cache_server, {:put, {:hello, "world"}})
22
23      send(cache_server, {:get, {:hello}})
24      assert_receive({:ok, "world"})
25      assert Process.alive?(cache_server)
26
27      send(cache_server, {:get, {:some}})
28      assert_receive({:error, :not_found})
29      assert Process.alive?(cache_server)
30    end
31
32    test "drop" do
33      parent = self()
34      cache_server = spawn(fn -> CacheServer.init(parent) end)
35      send(cache_server, {:put, {:hello, "world"}})
36
37      send(cache_server, {:drop, {:hello}})
38      assert_receive({:ok, :hello})
39      assert Process.alive?(cache_server)
40
41      send(cache_server, {:drop, {:some}})
42      assert_receive({:ok, :some})
43      assert Process.alive?(cache_server)
44    end
45
46    test "exit" do
47      parent = self()
48      cache_server = spawn(fn -> CacheServer.init(parent) end)
49
50      send(cache_server, {:exit})
51      assert_receive({:ok, :exited})
52      refute Process.alive?(cache_server)
53    end
54
55    test "unexpected input" do
56      parent = self()
57      cache_server = spawn(fn -> CacheServer.init(parent) end)
58
59      send(cache_server, {:something, {1, 2, 3}})
60      assert_receive({:error, :unrecognized_operation})
61      assert Process.alive?(cache_server)
62
63      send(cache_server, :boom)
64      assert_receive({:error, :unrecognized_operation})
65      assert Process.alive?(cache_server)
66    end
67  end
68end
69

Решение учителя откроется через:

20:00
waiting_clock