Erlangのプロセスとメッセージング
Erlangの中核的な並行性プリミティブであるプロセスを理解します。非同期メッセージパッシングによるプロセス間通信を学び、分離された軽量な並行処理単位を構築します。
「Erlangのプロセスとメッセージング」はCoddyKit上の無料Erlang OTP: Distributed & Fault-Tolerant Systems Programmingレッスンです。 これはレッスン2/4です。 下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。 これはErlang OTP: Distributed & Fault-Tolerant Systems Programming学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 Erlang OTP: Distributed & Fault-Tolerant Systems Programmingコースには全4レッスンが含まれています。
このレッスンの一部はまだ翻訳されておらず、英語で表示されています。
Erlang's Core: The Process
The fundamental unit of Erlang concurrency is the process: a tiny, independent program running alongside others, far lighter than an OS thread.
Why Erlang Processes?
Erlang processes are lightweight (millions per machine), isolated (no shared memory), concurrent, and talk only via async messages.
Spawning a New Process
You create a process with spawn, passing a module, function, and args. It returns a unique PID identifying the new process.
-module(process_spawn).
-export([start/0, hello_world_process/0]).
hello_world_process() ->
io:format("Hello from a new Erlang process!~n").
start() ->
% Spawns a new process running hello_world_process/0
Pid = spawn(process_spawn, hello_world_process, []),
io:format("Spawned process with PID: ~p~n", [Pid]).Understanding Process IDs (PIDs)
Every process gets a unique PID — its postal address. You need that PID to send it any message; it looks like <0.80.0>.
Sending Messages with '!'
Processes talk by messages, never shared memory. Send one with the ! operator: Pid ! Message, where the message is any Erlang term.
-module(message_sender).
-export([start/0, receiver_process/0, sender_process/1]).
receiver_process() ->
io:format("Receiver process ~p started.~n", [self()]),
% This process will just print its PID for now.
% It doesn't receive messages in this version.
timer:sleep(1000). % Keep process alive for a moment
sender_process(ReceiverPid) ->
io:format("Sender process ~p sending message to ~p...~n", [self(), ReceiverPid]),
ReceiverPid ! {hello, "from sender"},
io:format("Message sent!~n").
start() ->
ReceiverPid = spawn(message_sender, receiver_process, []),
io:format("Receiver spawned with PID: ~p~n", [ReceiverPid]),
sender_process(ReceiverPid).Receiving Messages: 'receive'
A process pulls messages from its mailbox with receive, which pattern-matches each one and waits (or times out) until a match arrives.
-module(message_receiver).
-export([start/0, my_receiver/0, my_sender/1]).
my_receiver() ->
io:format("Receiver ~p waiting for messages...~n", [self()]),
receive
{hello, Msg} ->
io:format("Receiver ~p received: ~p~n", [self(), Msg]);
_AnyOtherMessage ->
io:format("Receiver ~p received an unexpected message: ~p~n", [self(), _AnyOtherMessage])
end,
io:format("Receiver ~p finished.~n", [self()]).
my_sender(ReceiverPid) ->
io:format("Sender ~p sending message to ~p.~n", [self(), ReceiverPid]),
ReceiverPid ! {hello, "World"},
io:format("Sender ~p sent message.~n", [self()]).
start() ->
ReceiverPid = spawn(message_receiver, my_receiver, []),
timer:sleep(100), % Give receiver time to start
my_sender(ReceiverPid).A Full Messaging Example
Here is the full flow in one example: spawn a server, the client sends a request, and the server receives and replies.
-module(full_message_example).
-export([start/0, server_loop/0, client_action/1]).
server_loop() ->
io:format("Server ~p started, waiting for requests...~n", [self()]),
receive
{request, ClientPid, Message} ->
io:format("Server ~p received request from ~p: ~p~n", [self(), ClientPid, Message]),
ClientPid ! {response, self(), "Got your message!"};
_Other ->
io:format("Server ~p received unexpected: ~p~n", [self(), _Other])
end.
client_action(ServerPid) ->
io:format("Client ~p sending request to server ~p...~n", [self(), ServerPid]),
ServerPid ! {request, self(), "Can you hear me?"},
receive
{response, ServerPid, Reply} ->
io:format("Client ~p received reply from ~p: ~p~n", [self(), ServerPid, Reply])
end.
start() ->
ServerPid = spawn(full_message_example, server_loop, []),
timer:sleep(100), % Give server time to start
client_action(ServerPid).Asynchronous Communication
Erlang messaging is asynchronous: the sender drops the message in the mailbox and keeps going, never blocking on the receiver.
The Process Mailbox
Each process has a private mailbox where incoming messages queue. A receive scans it for a pattern match, usually in arrival order.
Knowing Your Own PID: `self()`
The built-in self() returns the current process's PID — handy for messaging yourself or embedding a reply address in a message.
-module(self_example).
-export([start/0, print_self/0]).
print_self() ->
io:format("Hello, my PID is: ~p~n", [self()]).
start() ->
io:format("Parent process PID: ~p~n", [self()]),
spawn(self_example, print_self, []).
Quick Check: Message Flow
Consider the following sequence of events in Erlang:
- Process A spawns Process B.
- Process A sends a message to Process B.
- Process B receives the message.
Which of the following statements about this interaction are true?
Recap: Processes & Messaging
Recap: processes communicate by async messages — spawn returns a PID, ! sends, receive matches, each has a mailbox, and self() gives your own PID.
よくある質問
「Erlangのプロセスとメッセージング」レッスンは無料ですか？
はい。「Erlangのプロセスとメッセージング」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、Erlang OTP: Distributed & Fault-Tolerant Systems Programmingコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 Erlang OTP: Distributed & Fault-Tolerant Systems Programmingコースには全4レッスンが含まれています。
「Erlangのプロセスとメッセージング」で何を学びますか？
Erlangの中核的な並行性プリミティブであるプロセスを理解します。非同期メッセージパッシングによるプロセス間通信を学び、分離された軽量な並行処理単位を構築します。 ブラウザで直接実行するハンズオンコードでErlang OTP: Distributed & Fault-Tolerant Systems Programmingを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。
Erlang OTP: Distributed & Fault-Tolerant Systems Programmingを始めるのに経験は必要ですか？
事前経験は必要ありません。CoddyKitのErlang OTP: Distributed & Fault-Tolerant Systems Programmingは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。 これはレッスン2/4です。
「Erlangのプロセスとメッセージング」レッスンにはどのくらい時間がかかりますか？
ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。
このErlang OTP: Distributed & Fault-Tolerant Systems Programmingレッスンでコードを書いて実行できますか？
はい。すべてのErlang OTP: Distributed & Fault-Tolerant Systems Programmingレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。
このコースのすべてのレッスン
- ErlangとVM入門
- Erlangのプロセスとメッセージング
- 基本的な並行処理パターン
- パターンマッチングとガード