Введение в супервизоры

In Erlang, processes are designed to crash! But who handles the mess? That's where Supervisors come in.

A supervisor is a special Erlang process whose job is to start, stop, and monitor other processes, called its children.

If a child process crashes, the supervisor automatically restarts it. This makes your applications incredibly resilient and fault-tolerant!

Imagine a web server process handling user requests. What happens if it crashes due to an error?

• Without a supervisor, the server stops, and users lose service.
• With a supervisor, the crashed process is detected and restarted instantly, often without users even noticing!

This "let it crash" philosophy, combined with supervisors, is key to Erlang's legendary reliability.

Supervisors are part of Erlang's Open Telecom Platform (OTP) framework. They follow a simple hierarchy:

• A supervisor has a list of child processes it's responsible for.
• Each child is defined by a child specification.
• If a child terminates unexpectedly, the supervisor steps in to restart it according to a defined strategy.

They form "supervision trees" where supervisors can supervise other supervisors.

Before a supervisor can manage a process, it needs to know how to start it. This is done via a child specification.

A child spec is a record (or map) containing details like:

• id: A unique name for the child.
• start: The module, function, and arguments to call to start the process.
• restart: When and how to restart (e.g., permanent, temporary).
• type: Whether it's a worker or another supervisor.

Supervisors use restart strategies to decide what to do when a child crashes. The most common is one_for_one.

With one_for_one:

• If a child process terminates, only that specific child process is restarted.
• Other sibling processes managed by the same supervisor are unaffected.

This strategy is ideal when children are independent and a failure in one doesn't impact the others.

Let's create a simple Erlang module that will act as a worker process. It will just start, print a message, and then we'll make it crash.

Now, let's create a supervisor module that will manage our my_worker. We'll specify the one_for_one restart strategy.

To see our supervisor in action, we need to start it. We can do this directly from the Erlang shell or a main application module.

Here's how to start it and check its children:

After compiling and running app_starter:start()., you should see "Worker started!". Now, call my_worker:crash_me(). in the shell.

What happens?

• The worker process will terminate ("Worker terminating!").
• The supervisor detects the crash and restarts the worker.
• You'll see "Worker started!" again, demonstrating automatic recovery!

This shows the power of supervisors in keeping your system running even when individual components fail.

Which of the following statements correctly describe the purpose or behavior of an Erlang supervisor with a one_for_one restart strategy?

Great job! You've learned the fundamentals of Erlang supervisors:

• They are special processes that monitor and restart child processes.
• They ensure fault tolerance and high availability by automatically recovering from crashes.
• Child specifications define how supervisors manage their children.
• The one_for_one strategy restarts only the failed child.

Supervisors are a cornerstone of robust Erlang/OTP applications. Next, we'll explore more advanced restart strategies!