Erlang生成问题

我对erlang中的“spawn”有问题，看起来进程在一段时间后就死了。下面是简单的代码：

-module(simple).
-export([server/1, client/1, owner/1, spawn_n/2, start/1, main/1]).

server(State) ->
receive
    {request,Return_PID} ->
        io:format("SERVER ~w: Client request recieved from ~w~n", [self(),Return_PID]),
        NewState = State + 1,
        Return_PID ! {hit_count,NewState},
        server(NewState);

    {server_owner,Owner_PID} ->
        io:format("SERVER ~w: Owner request recieved from ~w~n", [self(), Owner_PID]),
        Owner_PID ! {hit_count,State},
        server(State);
    reset ->
        io:format("SERVER ~w: State reset to zero.~n", [self()]),
        server(0)

end.



client(Server_Address) ->
Server_Address ! {request, self()},
receive
    {hit_count,Number} ->
        io:format("CLIENT ~w: Hit count was ~w~n", [self(),Number])
end.



owner(Server_PID) ->
timer:sleep(random:uniform(100)),
Server_PID ! {server_owner,self()},
receive 
    {hit_count,Number} when Number > 5 ->
        io:format("OWNER: Hit count is ~w , reseting counter. ~n", [Number]),
        Server_PID ! reset,
        owner(Server_PID);
    {hit_count,Number} when Number < 5 ->
        io:format("OWNER ~w: Hit count was ~w~n", [self(), Number]),
        owner(Server_PID)
end.




spawn_n(N, Server_PID) ->
if
    N>0 ->
        spawn(simple,client,[Server_PID]),
        timer:sleep(random:uniform(100)),
        spawn_n(N-1,Server_PID);
    N==0 ->
        io:format("Last client spawned. ~n")
end.



start(N) ->
Server_PID = spawn(simple,server,[0]),
spawn(simple,owner,[Server_PID]),
spawn(simple,spawn_n,[N,Server_PID]).


main([Arg]) ->
N = list_to_integer(atom_to_list(Arg)),
start(N),
init:stop().

-模块（简单）。
-导出（[server/1、client/1、owner/1、spawn\u n/2、start/1、main/1]）。
服务器（状态）->
接收
{请求，返回}->
io:format（“服务器~w:从~w~n接收到的客户端请求，[self（），Return_PID]），
NewState=State+1，
返回！{hit_count，NewState}，
服务器（NewState）；
{服务器\所有者，所有者\ PID}->
io:format（“从~w~n收到的服务器~w:Owner请求，[self（），Owner_PID]），
老板！{命中计数，状态}，
服务器（状态）；
重置->
io:格式（“服务器~w:状态重置为零。~n”，[self（）]），
服务器（0）
结束。
客户端（服务器地址）->
服务器地址！{request，self（）}，
接收
{点击次数，数字}->
io:format（“客户端~w:命中计数为~w~n”，[self（），Number]）
结束。
所有者（服务器\u PID）->
计时器：睡眠（随机：均匀（100）），
服务器&u-PID！{server_owner，self（）}，
接收
{hit_count，Number}当Number>5->
io:格式（“所有者：命中计数为~w，重置计数器~n，[Number]），
服务器&u-PID！重置，
所有者（服务器）；
{hit_count，Number}当Number<5->
io:格式（“所有者~w:命中计数为~w~n”，[self（），Number]），
所有者（服务器）
结束。
生成\u n（n，服务器\u PID）->
如果
N> 0->
生成（简单，客户端，[Server_PID]），
计时器：睡眠（随机：均匀（100）），
产卵n（n-1，服务器PID）；
N==0->
io:format（“上次生成的客户端。~n”）
结束。
开始（N）->
Server_PID=spawn（简单，服务器，[0]），
生成（简单，所有者，[Server_PID]），
spawn（简单，spawn，[n，Server\u-PID]）。
主（[Arg]）->
N=列表到整数（原子到列表（Arg）），
开始（N），
init:stop（）。

下面是我在运行它时得到的一个示例：

erl -noshell -s simple main 20

SERVER <0.28.0>: Client request recieved from <0.31.0>
CLIENT <0.31.0>: Hit count was 1
SERVER <0.28.0>: Owner request recieved from <0.29.0>
SERVER <0.28.0>: Client request recieved from <0.32.0>
OWNER <0.29.0>: Hit count was 1
CLIENT <0.32.0>: Hit count was 2
SERVER <0.28.0>: Owner request recieved from <0.29.0>
SERVER <0.28.0>: Client request recieved from <0.33.0>
OWNER <0.29.0>: Hit count was 2
CLIENT <0.33.0>: Hit count was 3
SERVER <0.28.0>: Owner request recieved from <0.29.0>
SERVER <0.28.0>: Client request recieved from <0.34.0>
OWNER <0.29.0>: Hit count was 3
CLIENT <0.34.0>: Hit count was 4
SERVER <0.28.0>: Owner request recieved from <0.29.0>
SERVER <0.28.0>: Client request recieved from <0.35.0>
OWNER <0.29.0>: Hit count was 4
CLIENT <0.35.0>: Hit count was 5
SERVER <0.28.0>: Owner request recieved from <0.29.0>
SERVER <0.28.0>: Client request recieved from <0.36.0>
CLIENT <0.36.0>: Hit count was 6
SERVER <0.28.0>: Client request recieved from <0.37.0>
CLIENT <0.37.0>: Hit count was 7
SERVER <0.28.0>: Client request recieved from <0.38.0>
CLIENT <0.38.0>: Hit count was 8
SERVER <0.28.0>: Client request recieved from <0.39.0>
CLIENT <0.39.0>: Hit count was 9
SERVER <0.28.0>: Client request recieved from <0.40.0>
CLIENT <0.40.0>: Hit count was 10
SERVER <0.28.0>: Client request recieved from <0.41.0>
CLIENT <0.41.0>: Hit count was 11
SERVER <0.28.0>: Client request recieved from <0.42.0>
CLIENT <0.42.0>: Hit count was 12
SERVER <0.28.0>: Client request recieved from <0.43.0>
CLIENT <0.43.0>: Hit count was 13
SERVER <0.28.0>: Client request recieved from <0.44.0>
CLIENT <0.44.0>: Hit count was 14
SERVER <0.28.0>: Client request recieved from <0.45.0>
CLIENT <0.45.0>: Hit count was 15
SERVER <0.28.0>: Client request recieved from <0.46.0>
CLIENT <0.46.0>: Hit count was 16
SERVER <0.28.0>: Client request recieved from <0.47.0>
CLIENT <0.47.0>: Hit count was 17
SERVER <0.28.0>: Client request recieved from <0.48.0>
CLIENT <0.48.0>: Hit count was 18
{error_logger,{{2011,6,27},{12,57,8}},"~s~n",["Error in process <0.28.0> with ex
it value: {terminated,[{io,format,[<0.22.0>,\"SERVER ~w: Client request recieved
 from ~w~n\",[<0.28.0>,<0.49.0>]]},{simple,server,1}]}\n"]}

erl-noshell-s简单main 20
服务器：从接收的客户端请求
客户：点击次数是1
服务器：从接收到所有者请求
服务器：从接收的客户端请求
所有者：命中率是1
客户：点击数是2
服务器：从接收到所有者请求
服务器：从接收的客户端请求
所有者：命中率是2
客户：点击数是3
服务器：从接收到所有者请求
服务器：从接收的客户端请求
所有者：命中率是3
客户：点击数是4
服务器：从接收到所有者请求
服务器：从接收的客户端请求
所有者：命中率是4
客户：点击数是5
服务器：从接收到所有者请求
服务器：从接收的客户端请求
客户：点击数是6
服务器：从接收的客户端请求
客户：点击数是7
服务器：从接收的客户端请求
客户：点击数是8
服务器：从接收的客户端请求
客户：点击数是9
服务器：从接收的客户端请求
客户：点击次数是10次
服务器：从接收的客户端请求
客户：点击数是11
服务器：从接收的客户端请求
客户：点击数是12
服务器：从接收的客户端请求
客户：点击数是13
服务器：从接收的客户端请求
客户：点击数是14
服务器：从接收的客户端请求
客户：点击数是15
服务器：从接收的客户端请求
客户：点击数是16
服务器：从接收的客户端请求
客户：点击数是17
服务器：从接收的客户端请求
客户：点击数是18
{error_logger，{{2011,6,27}，{12,57,8}，“~s~n”，[“使用ex的过程中出错”
它的值：{terminated，[{io，format，[，\”服务器~w：接收到客户端请求
从~w~n\”，[，]}，{simple，server，1}]}\n“]}

我不明白。这些过程只是死了还是什么？它不应该终止！ 我在Windows7上运行，如果它可能与windows相关

谢谢

编辑：下面是执行应用程序：启动（sasl）时发生的情况。之前：

C:\ProgramFiles\erl5.8.4\bin>erl
Eshell V5.8.4（使用^G中止）
1> 应用程序：启动（sasl）。
好啊
=进度报告===2011年6月27日：：16:03:55===
主管：{本地，sasl\U safe\U sup}
已启动：[{pid，}，
{名称，报警处理程序}，
{mfargs，{报警处理程序，启动链接，[]}，
{restart_type，permanent}，
{关闭，2000}，
{child_type，worker}]
2>
=进度报告===2011年6月27日：：16:03:55===
主管：{本地，sasl\U safe\U sup}
已启动：[{pid，}，
{name，重载}，
{mfargs，{重载，启动链接，[]}，
{restart_type，permanent}，
{关闭，2000}，
{child_type，worker}]
2>
=进度报告===2011年6月27日：：16:03:55===
主管：{本地，sasl_sup}
已启动：[{pid，}，
{name，sasl_safe_sup}，
{mfargs，
{主管，启动链接，
[{local，sasl_safe_sup}，sasl，safe
{restart_type，permanent}，
{关闭，无限}，
{child_type，supervisor}]
2>
=进度报告===2011年6月27日：：16:03:55===
主管：{本地，sasl_sup}
已启动：[{pid，}，
{name，release_handler}，
{mfargs，{release_handler，start_link，[]}
{restart_type，permanent}，
{关闭，2000}，
{child_type，worker}]
2>
=进度报告===2011年6月27日：：16:03:55===
应用：sasl
开始于：nonode@nohost
2> 简单：main（['20']）。
好啊
服务器：从接收的客户端请求
3> 客户：点击次数是1
3> 服务器：从接收到所有者请求
3> 服务器：从接收的客户端请求
3> 所有者：命中率是1
3> 客户：点击数是2
3> 服务器：从接收到所有者请求
3> 服务器：从接收的客户端请求
3> 所有者：命中率是2
3> 客户：点击数是3
3> 服务器：从接收到所有者请求
3> 服务器：从接收的客户端请求
3> 所有者：命中率是3
3> 客户：点击数是4
3>
C:\Program Files\erl5.8.4\bin>erl
Eshell V5.8.4  (abort with ^G)
1> application:start(sasl).
ok

=PROGRESS REPORT==== 27-Jun-2011::16:03:55 ===
          supervisor: {local,sasl_safe_sup}
             started: [{pid,<0.37.0>},
                       {name,alarm_handler},
                       {mfargs,{alarm_handler,start_link,[]}},
                       {restart_type,permanent},
                       {shutdown,2000},
                       {child_type,worker}]
2>
=PROGRESS REPORT==== 27-Jun-2011::16:03:55 ===
          supervisor: {local,sasl_safe_sup}
             started: [{pid,<0.38.0>},
                       {name,overload},
                       {mfargs,{overload,start_link,[]}},
                       {restart_type,permanent},
                       {shutdown,2000},
                       {child_type,worker}]
2>
=PROGRESS REPORT==== 27-Jun-2011::16:03:55 ===
          supervisor: {local,sasl_sup}
             started: [{pid,<0.36.0>},
                       {name,sasl_safe_sup},
                       {mfargs,
                           {supervisor,start_link,
                               [{local,sasl_safe_sup},sasl,safe
                       {restart_type,permanent},
                       {shutdown,infinity},
                       {child_type,supervisor}]
2>
=PROGRESS REPORT==== 27-Jun-2011::16:03:55 ===
          supervisor: {local,sasl_sup}
             started: [{pid,<0.39.0>},
                       {name,release_handler},
                       {mfargs,{release_handler,start_link,[]}}
                       {restart_type,permanent},
                       {shutdown,2000},
                       {child_type,worker}]
2>
=PROGRESS REPORT==== 27-Jun-2011::16:03:55 ===
         application: sasl
          started_at: nonode@nohost
2> simple:main(['20']).
ok
SERVER <0.42.0>: Client request recieved from <0.45.0>
3> CLIENT <0.45.0>: Hit count was 1
3> SERVER <0.42.0>: Owner request recieved from <0.43.0>
3> SERVER <0.42.0>: Client request recieved from <0.47.0>
3> OWNER <0.43.0>: Hit count was 1
3> CLIENT <0.47.0>: Hit count was 2
3> SERVER <0.42.0>: Owner request recieved from <0.43.0>
3> SERVER <0.42.0>: Client request recieved from <0.48.0>
3> OWNER <0.43.0>: Hit count was 2
3> CLIENT <0.48.0>: Hit count was 3
3> SERVER <0.42.0>: Owner request recieved from <0.43.0>
3> SERVER <0.42.0>: Client request recieved from <0.49.0>
3> OWNER <0.43.0>: Hit count was 3
3> CLIENT <0.49.0>: Hit count was 4
3> SERVER <0.42.0>: Owner request recieved from <0.43.0>
3> SERVER <0.42.0>: Client request recieved from <0.50.0>
3> OWNER <0.43.0>: Hit count was 4
3> CLIENT <0.50.0>: Hit count was 5
3> SERVER <0.42.0>: Owner request recieved from <0.43.0>
3> SERVER <0.42.0>: Client request recieved from <0.51.0>
3> CLIENT <0.51.0>: Hit count was 6
3> SERVER <0.42.0>: Client request recieved from <0.52.0>
3> CLIENT <0.52.0>: Hit count was 7
3> SERVER <0.42.0>: Client request recieved from <0.53.0>
3> CLIENT <0.53.0>: Hit count was 8
3> SERVER <0.42.0>: Client request recieved from <0.54.0>
3> CLIENT <0.54.0>: Hit count was 9
3> SERVER <0.42.0>: Client request recieved from <0.55.0>
3> CLIENT <0.55.0>: Hit count was 10
3> SERVER <0.42.0>: Client request recieved from <0.56.0>
3> CLIENT <0.56.0>: Hit count was 11
3> SERVER <0.42.0>: Client request recieved from <0.57.0>
3> CLIENT <0.57.0>: Hit count was 12
3> SERVER <0.42.0>: Client request recieved from <0.58.0>
3> CLIENT <0.58.0>: Hit count was 13
3> SERVER <0.42.0>: Client request recieved from <0.59.0>
3> CLIENT <0.59.0>: Hit count was 14
3> SERVER <0.42.0>: Client request recieved from <0.60.0>
3> CLIENT <0.60.0>: Hit count was 15
3> SERVER <0.42.0>: Client request recieved from <0.61.0>
3> CLIENT <0.61.0>: Hit count was 16
3> SERVER <0.42.0>: Client request recieved from <0.62.0>
3> CLIENT <0.62.0>: Hit count was 17
3> SERVER <0.42.0>: Client request recieved from <0.63.0>
3> CLIENT <0.63.0>: Hit count was 18
3> {error_logger,{{2011,6,27},{16,3,58}},"~s~n",["Error in proc
 exit value: {terminated,[{io,format,[<0.23.0>,\"SERVER ~w: Cli
ved from ~w~n\",[<0.42.0>,<0.64.0>]]},{simple,server,1}]}\n"]}

{error_logger,{{2011,6,27},{12,57,8}},"~s~n",["Error in process <0.28.0> with exit value: {terminated,[{io,format,[<0.22.0>,\"SERVER ~w: Client request recieved from ~w~n\",[<0.28.0>,<0.49.0>]]},{simple,server,1}]}\n"]}

case request(Io, Request) of
{error, Reason} ->
    [_Name | Args] = tuple_to_list(to_tuple(Request)),
    {'EXIT',{undef,[_Current|Mfas]}} = (catch erlang:error(undef)),
        MFA = {io, Func, [Io | Args]},
        exit({conv_reason(Func, Reason),[MFA|Mfas]});