Erlang 实现的 Web 服务器的线程池模拟不起作用

Question

代码如下：

-module(rudy).
-export([init/1,handler/1,request/1,reply/1, start/1, stop/0]).

start(Port) ->
  register(rudy, spawn(fun() ->
    init(Port) end)).

stop() ->
  exit(whereis(rudy), "time to die").

init(Port) ->
  Opt = [list, {active, false}, {reuseaddr, true}],
  case gen_tcp:listen(Port, Opt) of         % opens a listening socket
    {ok, Listen} ->
      spawn_many(3,Listen),
%%       handler(Listen),
      ok;
    {error, _Error} -> error
  end.

handler(Listen) ->
  case gen_tcp:accept(Listen) of            % listen to the socket
    {ok, Client} ->
      request(Client),
      gen_tcp:close(Client),
      handler(Listen);
    {error, _Error} -> error
  end.
%%   gen_tcp:close(Listen).            % close the socket

request(Client) ->
  Recv = gen_tcp:recv(Client, 0),
  case Recv of
    {ok, Str} ->
      Request = http:parse_request(Str),
      Response = reply(Request),
      gen_tcp:send(Client, Response);
    {error, Error} ->
      io:format("rudy: error: ~w~n", [Error])
  end,
  gen_tcp:close(Client).

reply({{get, URI, _}, _, _}) ->
  timer:sleep(40),
  http:ok(URI).

spawn_many(0, _Listen)-> ok;
spawn_many(N, Listen)->
  spawn(rudy,handler,[Listen]),
  spawn_many(N - 1, Listen).

rudy:start(8027).我打算创建 3 个监听套接字供客户端连接，但是在执行然后从 Web 浏览器访问http://localhost:8027/时，此代码不起作用。

罪魁祸首在哪里？非常感谢。

Answer 1

关于 Erlang 套接字需要了解的一件事是，打开套接字的进程控制它；打开套接字的进程控制它。当该进程终止时，运行时将关闭套接字。

考虑你的start/1功能：

start(Port) ->
  register(rudy, spawn(fun() ->
    init(Port) end)).

它生成该init/1函数，为其注册一个名称，然后返回。这意味着init/1正在一个新进程中运行，所以让我们看一下init/1：

init(Port) ->
  Opt = [list, {active, false}, {reuseaddr, true}],
  case gen_tcp:listen(Port, Opt) of         % opens a listening socket
    {ok, Listen} ->
      spawn_many(3,Listen),
%%       handler(Listen),
      ok;
    {error, _Error} -> error
  end.

新生成的进程init/1首先运行，调用gen_tcp:listen/2. 如果成功，它会调用spawn_many/2设置一些接受器；如果失败，它基本上会忽略该错误。但这是问题的关键：无论成功还是失败，init/1都会结束，因此产生它的进程也会结束，并且因为这个进程（监听套接字的控制进程）死亡，监听套接字被关闭。任何尝试使用该套接字的接受器都会因此失败，如果您要在函数中打印出错误条件，您会看到这一点handler/1。

解决这个问题的方法是让init/1进程等待，直到所有使用监听套接字的进程都消失。

实现此目的的一种方法是将init/1其 pid 传递给spawn_many（从而将其从 更改spawn_many/2为spawn_many/3），init/1在退出之前等待 3 条消息，然后更改handler/1为handler/2，将 pid 作为附加参数并在完成时向那里发送消息。等待所有消息的最简单方法init/1是让它调用递归函数，如下所示：

init(Port) ->
  Opt = [list, {active, false}, {reuseaddr, true}],
  case gen_tcp:listen(Port, Opt) of         % opens a listening socket
    {ok, Listen} ->
      Count = 3,
      spawn_many(Count,Listen,self()),
      wait_for_threads(Count);
      %%       handler(Listen),
    {error, _Error} ->
      error
  end.

wait_for_threads(0) ->
  ok;
wait_for_threads(Count) ->
  receive
    handler_done ->
      wait_for_threads(Count-1)
  end.

然后更改handler/1为handler/2并让它发送消息：

handler(Listen, Pid) ->
  case gen_tcp:accept(Listen) of            % listen to the socket
    {ok, Client} ->
      request(Client),
      gen_tcp:close(Client),
      handler(Listen, Pid);
    {error, _Error} ->
      error
  end,
  Pid ! handler_done.

不要忘记接受附加的 pid 参数spawn_many/3：

spawn_many(0, _Listen, _Pid)-> ok;
spawn_many(N, Listen, Pid)->
    spawn(rudy,handler,[Listen, Pid]),
    spawn_many(N - 1, Listen, Pid).

所有这些都足以使所有生成的接受器的监听套接字保持活动状态。