The Erlang Concurrency Model (L22) Flashcards
Traditionally, each thread is treated as a single entity along with the other threads of the same program.
False - traditionally treated as separate entities.
Treating each thread as a separate entity scales nicely, as the OS has full control.
False - too many threads leads to slices of allocated time that are too small.
The Erlang virtual machine creates its own super-lightweight threads. What are the pros to this?
A massive number of threads may be created with almost no resource overhead.
The Erlang virtual machine creates its own super-lightweight threads. What are the cons to this?
All threads must share the same block of CPU time.
How many functions does Erlang provide for creating tasks and communicating between them? What are they?
3 - spawn, send, receive.
What name is given to Erlangs lightweight threads?
Processes.
What does the spawn function return?
The process ID of the new process.
Give an example of using the spawn function to create a process.
Pid = spawn(module, func, args).
Child processes may execute prior to the parent process that created them.
True - there is no guarantee.
Concurrent Erlang application logic may depend on a rigid send/receive order.
False.
What do X & Y represent in the below send function call?
X ! Y
X is the process ID of the target process, ! is the send operator, Y is the message (one or more data items).
Receive blocks are always written within the listen() function.
False - “find” is an arbitrary function name.
What data structures can the following receive block accept?
listen() ->
receive
{dog, Name} ->
“Mr” ++ Name;
{cat, Name} ->
“Ms” ++ Name
end.
Tuples that either begin with the dog or cat atom (and which have 1 other element).
Receive blocks are terminated by what keyword?
end.
Receive blocks execute for all messages in the queue that match one of its patterns.
False, the listen function terminates after the first match.
Messages that don’t match any pattern of the receive block are deleted.
False - they go into a “save” queue that may be checked again at a later time.
Receive functions may only be invoked periodically.
False - they may be invoked continously.
What type of application continuously invokes receive operations?
Server applications (web or dbms server)
How are receive blocks continuously invoked if Erlang has limited support for iteration?
Using recursion: the receive block calls its own wrapper function.
How does a process obtain its own process ID for two way communication?
Using self().
Receive blocks may be nested.
True.
Implement a timeout option (2000 milliseconds) into the following receive block:
receive
{Msg} -> do_something(Msg)
end.
receive
{Msg} -> do_something(Msg)
after 2000 -> do_something()
end.
What does Erlang’s name registration service do?
Allows a process ID to be associated with a name/label.
Using Erlang’s name registration service, processes can obtain the ID of all known/unknown concurrent process.
False - not if the name of the other process isn’t known.
What function registers a process name with a process ID?
register(atomName, ID)
What function removes a process name from the name registration service?
unregister (atomName)
What does the following return?
whereis(atomName)
Returns the PID of atomName, or undefined if not found.
What does the following return?
registered()
A list of all currently registered processes.
It is possible to link processes together so that “supervisor” processes can be notified if a monitored process terminates.
True.
Use a guard on the following receive pattern so that matching is conditional:
receive {Flag, Name} -> (…)
receive {Flag, Name} [when Flag == 1] -> (…)
