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).

我打算为客户端创建3个侦听套接字，但是当执行rudy:start(8027).然后从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进程等待，直到使用listen套接字的所有进程都消失。

执行此操作的一种方法是让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.

别忘了接受spawn_many/3的额外pid参数：

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

这一切足以让所有产生的接受器保持监听套接字的活动。

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

1 个答案: