CODEWITHSUNDEEP
erlang
HotBlanket
HotBlanket

Reputation: 97

How to spawn a variable number of gen_servers in Erlang

Currently I am using lists:foreach in conjunction with spawn_link to start a variable number of "workers" for a project, the number of workers determined at start up. I'd like the workers to each be a gen_server, so that I can call asynchronous or synchronous messages in them (gen_server:cast, etc.) Is this possible?

Upvotes: 2

Views: 447

Answers (2)

Hynek -Pichi- Vychodil
Hynek -Pichi- Vychodil

Reputation: 26121

Nothing prevents you from calling my_worker:start_link instead of spawn_link.

In worker

-module(my_worker).

-behaviour(gen_server).

%% API

-export([start_link/1]).

%% gen_server callbacks

-export([init/1, ...]).

%% API

start_link(Arg) ->
    gen_server:start_link(?MODULE, Arg, []).

%% gen_server callbacks

init(Arg) ->
    ...

Then you can just launch it

[ {ok, _Pid} = my_worker:start_link(Arg) || Arg <- Args ].

If you like to put them under supervisor:

-module(my_sup).

-behaviour(supervisor).

%% API

-export([start_link/1]).

%% supervisor callbacks

-export([init/1]).

%% API

start_link(Argg) ->
    gen_server:start_link(?MODULE, Args).

%% supervisor callbacks

init(Args) ->
    Sup_flags = #{strategy => one_for_one, intensity => 1, period => 5},
    Child_specs = [ #{id => Id, start => MFA}
        || {Id, {_M, _F, _A} = MFA} <- Args ],
    {ok, {Sup_flags, Child_specs}}.

You can read their configuration from application:get_env/1,2,3 or database or whatever. You can start them afterward using supervisor:start_child/2. You can use simple_one_for_one and so on. It is just a process.

Upvotes: 1

BlackMamba
BlackMamba

Reputation: 10254

Yes, this is possible.

You can use simple_one_for_one: http://erlang.org/doc/man/supervisor.html#start_child-2

a simplified one_for_one supervisor, where all child processes are dynamically added instances of the same process type.

Here is a code example: master.erl is a supervisor:

-module(master).

-behaviour(supervisor).

%% API
-export([start_link/0]).

%% Supervisor callbacks
-export([init/1]).

-define(SERVER, ?MODULE).

start_link() ->
    supervisor:start_link({local, ?SERVER}, ?MODULE, []).

init([]) ->
    RestartStrategy = simple_one_for_one,
    MaxRestarts = 1000,
    MaxSecondsBetweenRestarts = 3600,

    SupFlags = {RestartStrategy, MaxRestarts, MaxSecondsBetweenRestarts},

    Restart = permanent,
    Shutdown = 2000,
    Type = worker,

    AChild = {'worker', {'worker', start_link, []},
          Restart, Shutdown, Type, ['worker']},

    {ok, {SupFlags, [AChild]}}.

worker.erl is child worker:

-module(worker).

-behaviour(gen_server).

%% API
-export([start_link/0]).
-export([start_link/1]).

%% gen_server callbacks
-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
     terminate/2, code_change/3]).

-define(SERVER, ?MODULE). 

-record(state, {}).

start_link() ->
    gen_server:start_link({local, ?SERVER}, ?MODULE, [], []).
start_link(I) ->
    ServerName = lists:flatten(io_lib:format("~p~p", [?SERVER, I])),
    io:format("I am ~p~n", [list_to_atom(ServerName)]),
    gen_server:start_link({local, list_to_atom(ServerName)}, ?MODULE, [], []).

init([]) ->
    {ok, #state{}}.


handle_call(_Request, _From, State) ->
    Reply = ok,
    {reply, Reply, State}.

handle_cast(calc, State) ->
     io:format("result 2+2=4~n"),
     {noreply, State};
handle_cast(calcbad, State) ->
     io:format("result 1/0~n"),
     1 / 0,
     {noreply, State};
handle_cast(_Msg, State) ->
    {noreply, State}.

handle_info(_Info, State) ->
    {noreply, State}.


terminate(_Reason, _State) ->
    ok.

code_change(_OldVsn, State, _Extra) ->
    {ok, State}.

In the erlang shell:

22> master:start_link().                                                               
{ok,<0.2475.0>}
23> lists:map(fun(X) -> supervisor:start_child(master, [X]) end, lists:seq(1, 10)).

Upvotes: 4

Related Questions