%% 最简单的进程
Pid = spawn(fun() ->
    io:format("Hello from process ~p!~n", [self()])
end).
%% Hello from process <0.123.0>!

%% spawn 返回 PID（进程标识符）
is_pid(Pid).  %% true

%% worker.erl
-module(worker).
-export([loop/0, start/0]).

start() ->
    spawn(?MODULE, loop, []).

loop() ->
    receive
        stop ->
            io:format("Worker stopping~n");
        {work, Task} ->
            io:format("Working on: ~p~n", [Task]),
            loop()
    end.

%% 使用
1> Pid = worker:start().
<0.123.0>
2> Pid ! {work, "process data"}.
Working on: process data
3> Pid ! stop.
Worker stopping

%% 语法：Pid ! Message
%% Message 可以是任意 Erlang 值

Pid ! hello.
Pid ! {data, [1, 2, 3]}.
Pid ! {self(), "request"}.

%% 发送给自己
self() ! ping.

%% 发送的返回值是消息本身
Msg = Pid ! hello.
%% Msg = hello

%% 基本 receive
receive
    Pattern1 -> Action1;
    Pattern2 -> Action2;
    ...
end.

%% 带超时的 receive
receive
    {reply, Data} -> Data
after 5000 ->
    timeout
end.

%% 匹配特定消息
receive
    {hello, Name} ->
        io:format("Hello, ~s!~n", [Name]);
    {bye, Name} ->
        io:format("Goodbye, ~s!~n", [Name])
end.

%% 带守卫的匹配
receive
    {data, N} when is_integer(N), N > 0 ->
        process(N);
    {data, N} when is_integer(N) ->
        io:format("Invalid: ~p~n", [N])
end.

%% 通配符匹配
receive
    _ -> ok  %% 匹配任何消息（不推荐，丢弃有用信息）
end.

%% 绑定变量
receive
    {request, From, Ref, Data} ->
        %% From = 发送方 PID
        %% Ref = 请求引用
        %% Data = 请求数据
        From ! {response, Ref, process(Data)}
end.

%% 普通超时
wait_for_message() ->
    receive
        {ready, Pid} -> {ok, Pid}
    after 5000 ->
        {error, timeout}
    end.

%% 无限等待（不设置 after）
wait_forever() ->
    receive
        stop -> ok
    end.

%% 零超时（立即返回，用于非阻塞检查）
check_mailbox() ->
    receive
        Msg -> {got, Msg}
    after 0 ->
        empty
    end.

%% 清空邮箱中的所有消息
flush() ->
    receive
        _Msg ->
            %% io:format("Flushing: ~p~n", [_Msg]),
            flush()
    after 0 ->
        ok
    end.

%% 使用 erlang:flush() 在 Shell 中清空

%% server.erl
-module(server).
-export([start/0, call/2, loop/0]).

start() ->
    spawn(?MODULE, loop, []).

%% 同步调用：发送请求并等待响应
call(Pid, Request) ->
    Ref = make_ref(),
    Pid ! {self(), Ref, Request},
    receive
        {Ref, Response} -> Response
    after 5000 ->
        {error, timeout}
    end.

loop() ->
    receive
        {From, Ref, {echo, Msg}} ->
            From ! {Ref, Msg},
            loop();
        {From, Ref, {add, A, B}} ->
            From ! {Ref, A + B},
            loop();
        {From, Ref, stop} ->
            From ! {Ref, ok}
    end.

$ erl
1> Pid = server:start().
<0.123.0>
2> server:call(Pid, {echo, "hello"}).
"hello"
3> server:call(Pid, {add, 3, 4}).
7
4> server:call(Pid, stop).
ok

%% 异步：只发送，不等待响应
cast(Pid, Msg) ->
    Pid ! {cast, Msg},
    ok.

%% 服务端处理
loop() ->
    receive
        {cast, Msg} ->
            handle_cast(Msg),
            loop();
        {From, Ref, Msg} ->
            From ! {Ref, handle_call(Msg)},
            loop()
    end.

%% 链接两个进程
Pid = spawn_link(fun() ->
    receive stop -> ok end
end).

%% 当一个进程崩溃时，链接的进程也会收到退出信号
%% 默认行为：双向崩溃（双向传播）

%% 设置 trap_exit 可以捕获退出信号
process_flag(trap_exit, true),

Pid = spawn_link(fun() ->
    receive stop -> ok end
end),

%% 当链接的进程崩溃时，收到消息而非崩溃
receive
    {'EXIT', Pid, Reason} ->
        io:format("Process ~p exited: ~p~n", [Pid, Reason])
end.

%% 监控另一个进程
Pid = spawn(fun() ->
    receive stop -> ok end
end),

Ref = monitor(process, Pid),

%% 当被监控的进程退出时，收到消息
%% 注意：不需要 trap_exit！
receive
    {'DOWN', Ref, process, Pid, Reason} ->
        io:format("Process ~p is down: ~p~n", [Pid, Reason])
end.

%% 注册进程（给 PID 起名字）
Pid = spawn(fun() ->
    receive stop -> ok end
end),
register(my_process, Pid).

%% 使用名字发送消息
my_process ! hello.

%% 查找注册的 PID
whereis(my_process).  %% Pid

%% 取消注册
unregister(my_process).

%% 已注册的进程列表
registered().

%% 每个名字只能注册一个进程
register(name1, Pid1).  %% ok
register(name1, Pid2).  %% 错误！badarg

%% 全局唯一
%% 只有已注册才能用名字发送消息
unregistered_name ! msg.  %% 错误！badarg

%% 当前进程信息
self().                      %% PID
process_info(self()).         %% 详细信息列表
process_info(self(), memory). %% 内存使用
process_info(self(), message_queue_len). %% 消息队列长度
process_info(self(), current_function).  %% 当前执行的函数
process_info(self(), reductions).        %% 执行步数

%% 所有进程
erlang:processes().          %% 所有进程 PID 列表
erlang:system_info(process_count). %% 进程数量

%% chat_room.erl
-module(chat_room).
-export([start/0, join/2, leave/2, send/3, loop/1]).

start() ->
    spawn(?MODULE, loop, [#{name => "General", members => #{}}]).

join(RoomPid, UserPid) ->
    Ref = make_ref(),
    RoomPid ! {join, self(), Ref, UserPid},
    receive {Ref, Result} -> Result end.

leave(RoomPid, UserPid) ->
    Ref = make_ref(),
    RoomPid ! {leave, self(), Ref, UserPid},
    receive {Ref, Result} -> Result end.

send(RoomPid, UserPid, Message) ->
    RoomPid ! {message, UserPid, Message},
    ok.

loop(#{members := Members} = State) ->
    receive
        {join, From, Ref, UserPid} ->
            monitor(process, UserPid),
            NewMembers = Members#{UserPid => true},
            broadcast(Members, {user_joined, UserPid}),
            From ! {Ref, ok},
            loop(State#{members => NewMembers});

        {leave, From, Ref, UserPid} ->
            NewMembers = maps:remove(UserPid, Members),
            broadcast(NewMembers, {user_left, UserPid}),
            From ! {Ref, ok},
            loop(State#{members => NewMembers});

        {message, UserPid, Message} ->
            broadcast(maps:remove(UserPid, Members),
                      {chat, UserPid, Message}),
            loop(State);

        {'DOWN', _Ref, process, UserPid, _Reason} ->
            NewMembers = maps:remove(UserPid, Members),
            broadcast(NewMembers, {user_left, UserPid}),
            loop(State#{members => NewMembers})
    end.

broadcast(Members, Msg) ->
    maps:foreach(fun(Pid, _) -> Pid ! Msg end, Members).

%% task_executor.erl
-module(task_executor).
-export([parallel_map/2, parallel_filter/2, pmap/2]).

%% 并行 map
-spec pmap(fun((A) -> B), [A]) -> [B].
pmap(Fun, List) ->
    Parent = self(),
    Pids = [spawn(fun() -> Parent ! {self(), Fun(X)} end) || X <- List],
    [receive {Pid, Result} -> Result end || Pid <- Pids].

%% 并行 map（带超时）
-spec parallel_map(fun((A) -> B), [A]) -> [B | {error, timeout}].
parallel_map(Fun, List) ->
    Parent = self(),
    Pids = [spawn(fun() -> Parent ! {self(), Fun(X)} end) || X <- List],
    [receive_result(Pid) || Pid <- Pids].

receive_result(Pid) ->
    receive
        {Pid, Result} -> Result
    after 10000 ->
        {error, timeout}
    end.

%% 并行过滤
-spec parallel_filter(fun((A) -> boolean()), [A]) -> [A].
parallel_filter(Pred, List) ->
    Pairs = pmap(fun(X) -> {X, Pred(X)} end, List),
    [X || {X, true} <- Pairs].

$ erl
1> c(task_executor).
{ok, task_executor}
2> task_executor:pmap(fun(X) -> X * X end, [1,2,3,4,5]).
[1,4,9,16,25]
3> task_executor:parallel_filter(fun(X) -> X rem 2 =:= 0 end, [1,2,3,4,5,6]).
[2,4,6]