@k2works/claude-code-booster 3.5.0 → 3.6.1

package/lib/assets/docs/article/functional-desgin-ppp/elixir/18-concurrency-system.md

@@ -1,466 +1,466 @@
-# 第18章: 並行処理システム
-
-## はじめに
-
-並行処理システムは、Elixir の強力な並行処理機能を活用して、イベント駆動、状態マシン、メッセージキューなどのパターンを実装します。OTP の GenServer と Agent を使用して、信頼性の高い並行処理を実現します。
-
-## 1. イベントバス (EventBus)
-
-### GenServer ベースの実装
-
-```elixir
-defmodule EventBus do
-  use GenServer
-
-  # クライアント API
-  def start_link(opts \\ []) do
-    name = Keyword.get(opts, :name, __MODULE__)
-    GenServer.start_link(__MODULE__, %{}, name: name)
-  end
-
-  def subscribe(topic, handler, bus \\ __MODULE__) do
-    GenServer.call(bus, {:subscribe, topic, handler})
-  end
-
-  def unsubscribe(topic, handler_id, bus \\ __MODULE__) do
-    GenServer.call(bus, {:unsubscribe, topic, handler_id})
-  end
-
-  def publish(topic, message, bus \\ __MODULE__) do
-    GenServer.call(bus, {:publish, topic, message})
-  end
-
-  def publish_async(topic, message, bus \\ __MODULE__) do
-    GenServer.cast(bus, {:publish, topic, message})
-  end
-
-  # サーバー コールバック
-  @impl true
-  def init(_opts) do
-    {:ok, %{subscriptions: %{}, next_id: 1}}
-  end
-
-  @impl true
-  def handle_call({:subscribe, topic, handler}, _from, state) do
-    id = state.next_id
-    subscriptions = Map.update(
-      state.subscriptions,
-      topic,
-      [{id, handler}],
-      fn handlers -> [{id, handler} | handlers] end
-    )
-    {:reply, {:ok, id}, %{state | subscriptions: subscriptions, next_id: id + 1}}
-  end
-
-  @impl true
-  def handle_call({:publish, topic, message}, _from, state) do
-    handlers = Map.get(state.subscriptions, topic, [])
-    results = Enum.map(handlers, fn {_id, handler} ->
-      try do
-        {:ok, handler.(message)}
-      rescue
-        e -> {:error, e}
-      end
-    end)
-    {:reply, results, state}
-  end
-
-  @impl true
-  def handle_cast({:publish, topic, message}, state) do
-    handlers = Map.get(state.subscriptions, topic, [])
-    Enum.each(handlers, fn {_id, handler} ->
-      Task.start(fn -> handler.(message) end)
-    end)
-    {:noreply, state}
-  end
-end
-```
-
-### 使用例
-
-```elixir
-# イベントバスの起動
-{:ok, _pid} = EventBus.start_link()
-
-# トピックに購読
-EventBus.subscribe(:user_created, fn user ->
-  IO.puts("User created: #{user.name}")
-end)
-
-# イベントを発行
-EventBus.publish(:user_created, %{name: "Alice"})
-```
-
-## 2. 状態マシン (StateMachine)
-
-### GenServer による実装
-
-```elixir
-defmodule StateMachine do
-  use GenServer
-
-  defstruct [:state, :transitions, :log]
-
-  def start_link(initial_state, transitions, opts \\ []) do
-    name = Keyword.get(opts, :name, __MODULE__)
-    GenServer.start_link(__MODULE__, {initial_state, transitions}, name: name)
-  end
-
-  def current_state(machine \\ __MODULE__) do
-    GenServer.call(machine, :current_state)
-  end
-
-  def trigger(event, machine \\ __MODULE__) do
-    GenServer.call(machine, {:trigger, event})
-  end
-
-  def history(machine \\ __MODULE__) do
-    GenServer.call(machine, :history)
-  end
-
-  @impl true
-  def init({initial_state, transitions}) do
-    {:ok, %__MODULE__{
-      state: initial_state,
-      transitions: transitions,
-      log: [{:init, initial_state, DateTime.utc_now()}]
-    }}
-  end
-
-  @impl true
-  def handle_call(:current_state, _from, machine) do
-    {:reply, machine.state, machine}
-  end
-
-  @impl true
-  def handle_call({:trigger, event}, _from, machine) do
-    case get_transition(machine, event) do
-      nil ->
-        {:reply, {:error, :invalid_transition}, machine}
-
-      {next_state, action} ->
-        action && action.()
-        log_entry = {event, next_state, DateTime.utc_now()}
-        updated = %{machine | state: next_state, log: [log_entry | machine.log]}
-        {:reply, {:ok, next_state}, updated}
-    end
-  end
-
-  defp get_transition(machine, event) do
-    machine.transitions
-    |> Map.get(machine.state, %{})
-    |> Map.get(event)
-  end
-end
-```
-
-### 電話システムの例
-
-```elixir
-defmodule PhoneSystem do
-  def create_transitions do
-    %{
-      :on_hook => %{
-        :lift_receiver => {:off_hook, nil}
-      },
-      :off_hook => %{
-        :dial => {:dialing, nil},
-        :hang_up => {:on_hook, nil}
-      },
-      :dialing => %{
-        :connected => {:connected, nil},
-        :busy => {:off_hook, fn -> IO.puts("Busy tone") end},
-        :hang_up => {:on_hook, nil}
-      },
-      :connected => %{
-        :hang_up => {:on_hook, nil},
-        :remote_hang_up => {:off_hook, nil}
-      }
-    }
-  end
-
-  def start_phone do
-    StateMachine.start_link(:on_hook, create_transitions(), name: :phone)
-  end
-end
-```
-
-## 3. メッセージキュー
-
-### GenServer による実装
-
-```elixir
-defmodule MessageQueue do
-  use GenServer
-
-  def start_link(opts \\ []) do
-    name = Keyword.get(opts, :name, __MODULE__)
-    GenServer.start_link(__MODULE__, :queue.new(), name: name)
-  end
-
-  def enqueue(message, queue \\ __MODULE__) do
-    GenServer.call(queue, {:enqueue, message})
-  end
-
-  def dequeue(queue \\ __MODULE__) do
-    GenServer.call(queue, :dequeue)
-  end
-
-  def peek(queue \\ __MODULE__) do
-    GenServer.call(queue, :peek)
-  end
-
-  def size(queue \\ __MODULE__) do
-    GenServer.call(queue, :size)
-  end
-
-  @impl true
-  def init(queue) do
-    {:ok, queue}
-  end
-
-  @impl true
-  def handle_call({:enqueue, message}, _from, queue) do
-    {:reply, :ok, :queue.in(message, queue)}
-  end
-
-  @impl true
-  def handle_call(:dequeue, _from, queue) do
-    case :queue.out(queue) do
-      {{:value, item}, new_queue} -> {:reply, {:ok, item}, new_queue}
-      {:empty, _} -> {:reply, {:error, :empty}, queue}
-    end
-  end
-
-  @impl true
-  def handle_call(:peek, _from, queue) do
-    case :queue.peek(queue) do
-      {:value, item} -> {:reply, {:ok, item}, queue}
-      :empty -> {:reply, {:error, :empty}, queue}
-    end
-  end
-
-  @impl true
-  def handle_call(:size, _from, queue) do
-    {:reply, :queue.len(queue), queue}
-  end
-end
-```
-
-## 4. ワーカープール
-
-### 並行タスク処理
-
-```elixir
-defmodule WorkerPool do
-  use GenServer
-
-  def start_link(worker_count, opts \\ []) do
-    name = Keyword.get(opts, :name, __MODULE__)
-    GenServer.start_link(__MODULE__, worker_count, name: name)
-  end
-
-  def submit(task, pool \\ __MODULE__) do
-    GenServer.call(pool, {:submit, task})
-  end
-
-  def submit_async(task, pool \\ __MODULE__) do
-    GenServer.cast(pool, {:submit, task})
-  end
-
-  def stats(pool \\ __MODULE__) do
-    GenServer.call(pool, :stats)
-  end
-
-  @impl true
-  def init(worker_count) do
-    {:ok, %{
-      workers: worker_count,
-      active: 0,
-      completed: 0,
-      pending: :queue.new()
-    }}
-  end
-
-  @impl true
-  def handle_call({:submit, task}, from, state) do
-    if state.active < state.workers do
-      spawn_worker(task, from, self())
-      {:noreply, %{state | active: state.active + 1}}
-    else
-      pending = :queue.in({task, from}, state.pending)
-      {:noreply, %{state | pending: pending}}
-    end
-  end
-
-  @impl true
-  def handle_info({:task_complete, result, from}, state) do
-    GenServer.reply(from, result)
-
-    case :queue.out(state.pending) do
-      {{:value, {task, pending_from}}, new_pending} ->
-        spawn_worker(task, pending_from, self())
-        {:noreply, %{state | pending: new_pending, completed: state.completed + 1}}
-
-      {:empty, _} ->
-        {:noreply, %{state | active: state.active - 1, completed: state.completed + 1}}
-    end
-  end
-
-  defp spawn_worker(task, from, pool_pid) do
-    Task.start(fn ->
-      result = task.()
-      send(pool_pid, {:task_complete, result, from})
-    end)
-  end
-end
-```
-
-### 使用例
-
-```elixir
-# プールを起動（3ワーカー）
-{:ok, _} = WorkerPool.start_link(3)
-
-# タスクを投入
-results = Enum.map(1..10, fn i ->
-  WorkerPool.submit(fn ->
-    Process.sleep(100)
-    i * 2
-  end)
-end)
-
-# 結果: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
-```
-
-## 5. カウンター (Agent)
-
-### シンプルな状態管理
-
-```elixir
-defmodule Counter do
-  use Agent
-
-  def start_link(initial \\ 0, opts \\ []) do
-    name = Keyword.get(opts, :name, __MODULE__)
-    Agent.start_link(fn -> initial end, name: name)
-  end
-
-  def value(counter \\ __MODULE__) do
-    Agent.get(counter, & &1)
-  end
-
-  def increment(counter \\ __MODULE__) do
-    Agent.update(counter, &(&1 + 1))
-  end
-
-  def increment_by(amount, counter \\ __MODULE__) do
-    Agent.update(counter, &(&1 + amount))
-  end
-
-  def decrement(counter \\ __MODULE__) do
-    Agent.update(counter, &(&1 - 1))
-  end
-
-  def reset(counter \\ __MODULE__) do
-    Agent.update(counter, fn _ -> 0 end)
-  end
-end
-```
-
-## 6. 安全な停止処理
-
-### Process.alive? によるチェック
-
-並行プロセスを停止する際は、プロセスが生きているか確認が必要です：
-
-```elixir
-def stop(pid) do
-  if Process.alive?(pid) do
-    GenServer.stop(pid)
-  end
-end
-
-# Agent の場合
-def stop_counter(counter \\ __MODULE__) do
-  pid = case counter do
-    name when is_atom(name) -> Process.whereis(name)
-    pid when is_pid(pid) -> pid
-  end
-
-  if pid && Process.alive?(pid) do
-    Agent.stop(pid)
-  end
-end
-```
-
-### テストでのクリーンアップ
-
-```elixir
-setup do
-  {:ok, pid} = EventBus.start_link(name: :test_bus)
-  on_exit(fn ->
-    if Process.alive?(pid), do: GenServer.stop(pid)
-  end)
-  %{bus: pid}
-end
-```
-
-## 7. パターンの比較
-
-### GenServer vs Agent
-
-| GenServer | Agent |
-|-----------|-------|
-| 複雑な状態管理 | シンプルな状態管理 |
-| 非同期メッセージ処理 | 同期的な更新 |
-| タイムアウト、継続など | 状態の取得・更新のみ |
-| コールバック関数を実装 | 匿名関数で操作 |
-
-### 使い分けの指針
-
-- **Agent**: 単純なキー値ストア、カウンター、キャッシュ
-- **GenServer**: イベント処理、状態マシン、プロトコル実装
-
-## 8. テストの例
-
-```elixir
-test "EventBus publish and subscribe" do
-  {:ok, _} = EventBus.start_link(name: :test_bus)
-
-  messages = Agent.start_link(fn -> [] end) |> elem(1)
-
-  EventBus.subscribe(:test, fn msg ->
-    Agent.update(messages, &[msg | &1])
-  end, :test_bus)
-
-  EventBus.publish(:test, "hello", :test_bus)
-  EventBus.publish(:test, "world", :test_bus)
-
-  assert Agent.get(messages, & &1) == ["world", "hello"]
-end
-
-test "StateMachine transitions" do
-  transitions = %{
-    :idle => %{start: {:running, nil}},
-    :running => %{stop: {:idle, nil}}
-  }
-
-  {:ok, _} = StateMachine.start_link(:idle, transitions, name: :test_sm)
-
-  assert StateMachine.current_state(:test_sm) == :idle
-  assert StateMachine.trigger(:start, :test_sm) == {:ok, :running}
-  assert StateMachine.current_state(:test_sm) == :running
-end
-```
-
-## まとめ
-
-Elixir の並行処理システムは、OTP の抽象化によって以下を実現します：
-
-1. **信頼性**: GenServer のスーパービジョンツリーによる障害復旧
-2. **スケーラビリティ**: 軽量プロセスによる大量の並行処理
-3. **明確なプロトコル**: call/cast による同期/非同期の明示的な区別
-4. **テスタビリティ**: 名前付きプロセスによるテスト容易性
-
-これらのパターンを組み合わせることで、複雑な並行システムを安全に構築できます。
+# 第18章: 並行処理システム
+
+## はじめに
+
+並行処理システムは、Elixir の強力な並行処理機能を活用して、イベント駆動、状態マシン、メッセージキューなどのパターンを実装します。OTP の GenServer と Agent を使用して、信頼性の高い並行処理を実現します。
+
+## 1. イベントバス (EventBus)
+
+### GenServer ベースの実装
+
+```elixir
+defmodule EventBus do
+  use GenServer
+
+  # クライアント API
+  def start_link(opts \\ []) do
+    name = Keyword.get(opts, :name, __MODULE__)
+    GenServer.start_link(__MODULE__, %{}, name: name)
+  end
+
+  def subscribe(topic, handler, bus \\ __MODULE__) do
+    GenServer.call(bus, {:subscribe, topic, handler})
+  end
+
+  def unsubscribe(topic, handler_id, bus \\ __MODULE__) do
+    GenServer.call(bus, {:unsubscribe, topic, handler_id})
+  end
+
+  def publish(topic, message, bus \\ __MODULE__) do
+    GenServer.call(bus, {:publish, topic, message})
+  end
+
+  def publish_async(topic, message, bus \\ __MODULE__) do
+    GenServer.cast(bus, {:publish, topic, message})
+  end
+
+  # サーバー コールバック
+  @impl true
+  def init(_opts) do
+    {:ok, %{subscriptions: %{}, next_id: 1}}
+  end
+
+  @impl true
+  def handle_call({:subscribe, topic, handler}, _from, state) do
+    id = state.next_id
+    subscriptions = Map.update(
+      state.subscriptions,
+      topic,
+      [{id, handler}],
+      fn handlers -> [{id, handler} | handlers] end
+    )
+    {:reply, {:ok, id}, %{state | subscriptions: subscriptions, next_id: id + 1}}
+  end
+
+  @impl true
+  def handle_call({:publish, topic, message}, _from, state) do
+    handlers = Map.get(state.subscriptions, topic, [])
+    results = Enum.map(handlers, fn {_id, handler} ->
+      try do
+        {:ok, handler.(message)}
+      rescue
+        e -> {:error, e}
+      end
+    end)
+    {:reply, results, state}
+  end
+
+  @impl true
+  def handle_cast({:publish, topic, message}, state) do
+    handlers = Map.get(state.subscriptions, topic, [])
+    Enum.each(handlers, fn {_id, handler} ->
+      Task.start(fn -> handler.(message) end)
+    end)
+    {:noreply, state}
+  end
+end
+```
+
+### 使用例
+
+```elixir
+# イベントバスの起動
+{:ok, _pid} = EventBus.start_link()
+
+# トピックに購読
+EventBus.subscribe(:user_created, fn user ->
+  IO.puts("User created: #{user.name}")
+end)
+
+# イベントを発行
+EventBus.publish(:user_created, %{name: "Alice"})
+```
+
+## 2. 状態マシン (StateMachine)
+
+### GenServer による実装
+
+```elixir
+defmodule StateMachine do
+  use GenServer
+
+  defstruct [:state, :transitions, :log]
+
+  def start_link(initial_state, transitions, opts \\ []) do
+    name = Keyword.get(opts, :name, __MODULE__)
+    GenServer.start_link(__MODULE__, {initial_state, transitions}, name: name)
+  end
+
+  def current_state(machine \\ __MODULE__) do
+    GenServer.call(machine, :current_state)
+  end
+
+  def trigger(event, machine \\ __MODULE__) do
+    GenServer.call(machine, {:trigger, event})
+  end
+
+  def history(machine \\ __MODULE__) do
+    GenServer.call(machine, :history)
+  end
+
+  @impl true
+  def init({initial_state, transitions}) do
+    {:ok, %__MODULE__{
+      state: initial_state,
+      transitions: transitions,
+      log: [{:init, initial_state, DateTime.utc_now()}]
+    }}
+  end
+
+  @impl true
+  def handle_call(:current_state, _from, machine) do
+    {:reply, machine.state, machine}
+  end
+
+  @impl true
+  def handle_call({:trigger, event}, _from, machine) do
+    case get_transition(machine, event) do
+      nil ->
+        {:reply, {:error, :invalid_transition}, machine}
+
+      {next_state, action} ->
+        action && action.()
+        log_entry = {event, next_state, DateTime.utc_now()}
+        updated = %{machine | state: next_state, log: [log_entry | machine.log]}
+        {:reply, {:ok, next_state}, updated}
+    end
+  end
+
+  defp get_transition(machine, event) do
+    machine.transitions
+    |> Map.get(machine.state, %{})
+    |> Map.get(event)
+  end
+end
+```
+
+### 電話システムの例
+
+```elixir
+defmodule PhoneSystem do
+  def create_transitions do
+    %{
+      :on_hook => %{
+        :lift_receiver => {:off_hook, nil}
+      },
+      :off_hook => %{
+        :dial => {:dialing, nil},
+        :hang_up => {:on_hook, nil}
+      },
+      :dialing => %{
+        :connected => {:connected, nil},
+        :busy => {:off_hook, fn -> IO.puts("Busy tone") end},
+        :hang_up => {:on_hook, nil}
+      },
+      :connected => %{
+        :hang_up => {:on_hook, nil},
+        :remote_hang_up => {:off_hook, nil}
+      }
+    }
+  end
+
+  def start_phone do
+    StateMachine.start_link(:on_hook, create_transitions(), name: :phone)
+  end
+end
+```
+
+## 3. メッセージキュー
+
+### GenServer による実装
+
+```elixir
+defmodule MessageQueue do
+  use GenServer
+
+  def start_link(opts \\ []) do
+    name = Keyword.get(opts, :name, __MODULE__)
+    GenServer.start_link(__MODULE__, :queue.new(), name: name)
+  end
+
+  def enqueue(message, queue \\ __MODULE__) do
+    GenServer.call(queue, {:enqueue, message})
+  end
+
+  def dequeue(queue \\ __MODULE__) do
+    GenServer.call(queue, :dequeue)
+  end
+
+  def peek(queue \\ __MODULE__) do
+    GenServer.call(queue, :peek)
+  end
+
+  def size(queue \\ __MODULE__) do
+    GenServer.call(queue, :size)
+  end
+
+  @impl true
+  def init(queue) do
+    {:ok, queue}
+  end
+
+  @impl true
+  def handle_call({:enqueue, message}, _from, queue) do
+    {:reply, :ok, :queue.in(message, queue)}
+  end
+
+  @impl true
+  def handle_call(:dequeue, _from, queue) do
+    case :queue.out(queue) do
+      {{:value, item}, new_queue} -> {:reply, {:ok, item}, new_queue}
+      {:empty, _} -> {:reply, {:error, :empty}, queue}
+    end
+  end
+
+  @impl true
+  def handle_call(:peek, _from, queue) do
+    case :queue.peek(queue) do
+      {:value, item} -> {:reply, {:ok, item}, queue}
+      :empty -> {:reply, {:error, :empty}, queue}
+    end
+  end
+
+  @impl true
+  def handle_call(:size, _from, queue) do
+    {:reply, :queue.len(queue), queue}
+  end
+end
+```
+
+## 4. ワーカープール
+
+### 並行タスク処理
+
+```elixir
+defmodule WorkerPool do
+  use GenServer
+
+  def start_link(worker_count, opts \\ []) do
+    name = Keyword.get(opts, :name, __MODULE__)
+    GenServer.start_link(__MODULE__, worker_count, name: name)
+  end
+
+  def submit(task, pool \\ __MODULE__) do
+    GenServer.call(pool, {:submit, task})
+  end
+
+  def submit_async(task, pool \\ __MODULE__) do
+    GenServer.cast(pool, {:submit, task})
+  end
+
+  def stats(pool \\ __MODULE__) do
+    GenServer.call(pool, :stats)
+  end
+
+  @impl true
+  def init(worker_count) do
+    {:ok, %{
+      workers: worker_count,
+      active: 0,
+      completed: 0,
+      pending: :queue.new()
+    }}
+  end
+
+  @impl true
+  def handle_call({:submit, task}, from, state) do
+    if state.active < state.workers do
+      spawn_worker(task, from, self())
+      {:noreply, %{state | active: state.active + 1}}
+    else
+      pending = :queue.in({task, from}, state.pending)
+      {:noreply, %{state | pending: pending}}
+    end
+  end
+
+  @impl true
+  def handle_info({:task_complete, result, from}, state) do
+    GenServer.reply(from, result)
+
+    case :queue.out(state.pending) do
+      {{:value, {task, pending_from}}, new_pending} ->
+        spawn_worker(task, pending_from, self())
+        {:noreply, %{state | pending: new_pending, completed: state.completed + 1}}
+
+      {:empty, _} ->
+        {:noreply, %{state | active: state.active - 1, completed: state.completed + 1}}
+    end
+  end
+
+  defp spawn_worker(task, from, pool_pid) do
+    Task.start(fn ->
+      result = task.()
+      send(pool_pid, {:task_complete, result, from})
+    end)
+  end
+end
+```
+
+### 使用例
+
+```elixir
+# プールを起動（3ワーカー）
+{:ok, _} = WorkerPool.start_link(3)
+
+# タスクを投入
+results = Enum.map(1..10, fn i ->
+  WorkerPool.submit(fn ->
+    Process.sleep(100)
+    i * 2
+  end)
+end)
+
+# 結果: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
+```
+
+## 5. カウンター (Agent)
+
+### シンプルな状態管理
+
+```elixir
+defmodule Counter do
+  use Agent
+
+  def start_link(initial \\ 0, opts \\ []) do
+    name = Keyword.get(opts, :name, __MODULE__)
+    Agent.start_link(fn -> initial end, name: name)
+  end
+
+  def value(counter \\ __MODULE__) do
+    Agent.get(counter, & &1)
+  end
+
+  def increment(counter \\ __MODULE__) do
+    Agent.update(counter, &(&1 + 1))
+  end
+
+  def increment_by(amount, counter \\ __MODULE__) do
+    Agent.update(counter, &(&1 + amount))
+  end
+
+  def decrement(counter \\ __MODULE__) do
+    Agent.update(counter, &(&1 - 1))
+  end
+
+  def reset(counter \\ __MODULE__) do
+    Agent.update(counter, fn _ -> 0 end)
+  end
+end
+```
+
+## 6. 安全な停止処理
+
+### Process.alive? によるチェック
+
+並行プロセスを停止する際は、プロセスが生きているか確認が必要です：
+
+```elixir
+def stop(pid) do
+  if Process.alive?(pid) do
+    GenServer.stop(pid)
+  end
+end
+
+# Agent の場合
+def stop_counter(counter \\ __MODULE__) do
+  pid = case counter do
+    name when is_atom(name) -> Process.whereis(name)
+    pid when is_pid(pid) -> pid
+  end
+
+  if pid && Process.alive?(pid) do
+    Agent.stop(pid)
+  end
+end
+```
+
+### テストでのクリーンアップ
+
+```elixir
+setup do
+  {:ok, pid} = EventBus.start_link(name: :test_bus)
+  on_exit(fn ->
+    if Process.alive?(pid), do: GenServer.stop(pid)
+  end)
+  %{bus: pid}
+end
+```
+
+## 7. パターンの比較
+
+### GenServer vs Agent
+
+| GenServer | Agent |
+|-----------|-------|
+| 複雑な状態管理 | シンプルな状態管理 |
+| 非同期メッセージ処理 | 同期的な更新 |
+| タイムアウト、継続など | 状態の取得・更新のみ |
+| コールバック関数を実装 | 匿名関数で操作 |
+
+### 使い分けの指針
+
+- **Agent**: 単純なキー値ストア、カウンター、キャッシュ
+- **GenServer**: イベント処理、状態マシン、プロトコル実装
+
+## 8. テストの例
+
+```elixir
+test "EventBus publish and subscribe" do
+  {:ok, _} = EventBus.start_link(name: :test_bus)
+
+  messages = Agent.start_link(fn -> [] end) |> elem(1)
+
+  EventBus.subscribe(:test, fn msg ->
+    Agent.update(messages, &[msg | &1])
+  end, :test_bus)
+
+  EventBus.publish(:test, "hello", :test_bus)
+  EventBus.publish(:test, "world", :test_bus)
+
+  assert Agent.get(messages, & &1) == ["world", "hello"]
+end
+
+test "StateMachine transitions" do
+  transitions = %{
+    :idle => %{start: {:running, nil}},
+    :running => %{stop: {:idle, nil}}
+  }
+
+  {:ok, _} = StateMachine.start_link(:idle, transitions, name: :test_sm)
+
+  assert StateMachine.current_state(:test_sm) == :idle
+  assert StateMachine.trigger(:start, :test_sm) == {:ok, :running}
+  assert StateMachine.current_state(:test_sm) == :running
+end
+```
+
+## まとめ
+
+Elixir の並行処理システムは、OTP の抽象化によって以下を実現します：
+
+1. **信頼性**: GenServer のスーパービジョンツリーによる障害復旧
+2. **スケーラビリティ**: 軽量プロセスによる大量の並行処理
+3. **明確なプロトコル**: call/cast による同期/非同期の明示的な区別
+4. **テスタビリティ**: 名前付きプロセスによるテスト容易性
+
+これらのパターンを組み合わせることで、複雑な並行システムを安全に構築できます。