erlang进程概述

一、概述

与大多数的进程相反，Erlang中的并发很廉价，派生出一个进程就跟面向对象的语言中分配一个对象的开销差不多。在启动一个复杂的运算时，启动运算、派生进程以及返回结果后，所有进程神奇的烟消云散，它们的内存、邮箱、所持有的数据库句柄、它们打开的套接字，以及一些不乐意手工清理的东西，都一并消失。

Erlang进程不是操作系统进程，它们由erlang运行时系统实现，比线程要轻量的多，单个erlang系统可以轻易地派生出成百上千个进程。运行时系统中所有的进程都是隔离的，单个进程的内存不与其他进程共享，也不会被濒死或跑疯的进程破坏。

在操作系统中，典型的线程会在地址空间中为自己预留数兆的栈空间（也就是说32位的机器上并发线程最多也就几千个），栈空间溢出便会导致崩溃。erlang进程在启动时栈空间只有几百个字节，并会按需伸缩。

二、示例

 14> Pid = spawn(fun() -> timer:sleep(60000), primes:primelist(100000) end).    %% 派生一个进程，等待1分钟后做素数运算。 素数功能代码已提前编写好。

 <0.55.0>

 15> erlang:process_info(Pid).

 [{current_function,{timer,sleep,1}},

  {initial_call,{erlang,apply,2}},

  {status,waiting},

  {message_queue_len,0},

  {messages,[]},

  {links,[]},

  {dictionary,[]},

  {trap_exit,false},

  {error_handler,error_handler},

  {priority,normal},

  {group_leader,<0.26.0>},

  {total_heap_size,233},

  {heap_size,233},       %%刚启动的erlang进程所占的堆的大小仅为233字节，栈的大小10个字节。

  {stack_size,10},

  {reductions,43},       %%创建erlang进程仅消耗了43个reductions， 可见erlang的轻量。

  {garbage_collection,[{min_bin_vheap_size,46422},

                       {min_heap_size,233},

                       {fullsweep_after,65535},

                       {minor_gcs,0}]},

  {suspending,[]}]

 17> erlang:statistics(run_queue).     %% 进程处于挂起状态，堆、栈、时间片消耗都不会变

 0

 22> erlang:statistics(run_queue).     %% 进程进入运行队列，准备被调度。

 1

 23> erlang:process_info(Pid).

 [{current_function,{primes,'-primelist/3-lc$^0/1-0-',2}},

  {initial_call,{erlang,apply,2}},

  {status,runnable},

  {message_queue_len,0},

  {messages,[]},

  {links,[]},

  {dictionary,[]},

  {trap_exit,false},

  {error_handler,error_handler},

  {priority,normal},

  {group_leader,<0.26.0>},

  {total_heap_size,393300},

  {heap_size,75113},      %%进程在做素数计算， 堆栈大小随着需要开始增加。 消耗的时间片也会随着计算量增加而增加。

  {stack_size,13773},

  {reductions,89874499},

  {garbage_collection,[{min_bin_vheap_size,46422},

                       {min_heap_size,233},

                       {fullsweep_after,65535},

                       {minor_gcs,3085}]},

  {suspending,[]}]

 27> erlang:statistics(run_queue).

 0

 29> erlang:process_info(Pid).

 [{current_function,{primes,'-primelist/3-lc$^0/1-0-',2}},

  {initial_call,{erlang,apply,2}},

  {status,runnable},

  {message_queue_len,0},

  {messages,[]},

  {links,[]},

  {dictionary,[]},

  {trap_exit,false},

  {error_handler,error_handler},

  {priority,normal},

  {group_leader,<0.26.0>},

  {total_heap_size,393300},

  {heap_size,75113},

  {stack_size,87},     %% 随着计算的结束， 栈空间开始收缩， 这里可以看到堆空间没有变，堆的分配是由erlang GC来控制的， 进程结束时由GC来回收。

  {reductions,958602600},

  {garbage_collection,[{min_bin_vheap_size,46422},

                       {min_heap_size,233},

                       {fullsweep_after,65535},

                       {minor_gcs,33117}]},

  {suspending,[]}]

三、进程的调度

由于Erlang虚拟机对SMP的支持，每个操作系统线程都可以运行在一个调度器上，每个调度器拥有一自己的运行队列，这样避免了多个调度器同时调度在运行队列中的任务产生的冲突，但是如何保证调度队列任务分配的公平性，Erlang引入了一个高效和公平的概念，迁移逻辑。迁移逻辑利用在系统中收集的统计数据，控制和平衡了队列。

Erlang启动模拟器的时候可以加上+S去指定最大调度器数和可用调度器数。可用调度器数可以在模拟器运行时更改。

 -> erl +S 16:8

Erlang R16B03-1 (erts-5.10.4) [source] [64-bit] [smp:16:8] [async-threads:10] [hipe] [kernel-poll:false]

Eshell V5.10.4  (abort with ^G)

1> erlang:system_info(schedulers_online).

8

2> erlang:system_info(schedulers).

16

下面我们尝试起多个erlang进程去做素数运算，然后看看调度队列情况。

 -> erl +S 8:8     %%启动8个调度器同时可用。

Erlang R16B03-1 (erts-5.10.4) [source] [64-bit] [smp:8:8] [async-threads:10] [hipe] [kernel-poll:false]

Eshell V5.10.4  (abort with ^G)

1>  erlang:statistics(run_queue).        %%之前没有任务进入调度队列

0

2> [spawn(fun() -> timer:sleep(5000), primes:primelist(10000) end) || _ <- lists:seq(1, 10)].           %% 同时启动10个进程做素数运算

[<0.36.0>,<0.37.0>,<0.38.0>,<0.39.0>,<0.40.0>,<0.41.0>,

 <0.42.0>,<0.43.0>,<0.44.0>,<0.45.0>]

5>  erlang:statistics(run_queue).            %%同时有7个进程被调度运行，3个进程出去准备状态

3

7>  erlang:statistics(run_queue).            %%两个任务被换入。

1

8>  erlang:statistics(run_queue).            %%任务执行完毕，没有任务处于等待状态。

0

　　那么问题来了，在同样的硬件环境下，是不是调度器越多，进程处理的速度越快呢？列出测试结果：

 -> erl +S 4:4     %%%启动4个可用调度器

Erlang R16B03-1 (erts-5.10.4) [source] [64-bit] [smp:4:4] [async-threads:10] [hipe] [kernel-poll:false]

2> [spawn(fun() -> {P1, _P2} = timer:tc(primes, primelist, [100000]), io:format("timer:~p~n", [P1]) end) || _ <- lists:seq(1, 10)].

timer:185078651

timer:190735178

timer:192956743

timer:193186850

timer:220074562

timer:222929652

timer:234756209

timer:235304593

timer:235474721

timer:236500425

 -> erl +S 8:8   %%%启动8个可用调度器

Erlang R16B03-1 (erts-5.10.4) [source] [64-bit] [smp:8:8] [async-threads:10] [hipe] [kernel-poll:false]

Eshell V5.10.4  (abort with ^G)

1>

1>

1>

1> [spawn(fun() -> {P1, _P2} = timer:tc(primes, primelist, [100000]), io:format("timer:~p~n", [P1]) end) || _ <- lists:seq(1, 10)].

[<0.35.0>,<0.36.0>,<0.37.0>,<0.38.0>,<0.39.0>,<0.40.0>,

 <0.41.0>,<0.42.0>,<0.43.0>,<0.44.0>]

timer:187405676

timer:187568120

timer:188255698

timer:188577806

timer:190819642

timer:191208176

timer:235470698

timer:236842370

timer:237630863

timer:238206383

 -> erl +S 16:11

Erlang R16B03-1 (erts-5.10.4) [source] [64-bit] [smp:16:11] [async-threads:10] [hipe] [kernel-poll:false]

Eshell V5.10.4  (abort with ^G)

1> [spawn(fun() -> {P1, _P2} = timer:tc(primes, primelist, [100000]), io:format("timer:~p~n", [P1]) end) || _ <- lists:seq(1, 10)].

[<0.35.0>,<0.36.0>,<0.37.0>,<0.38.0>,<0.39.0>,<0.40.0>,

 <0.41.0>,<0.42.0>,<0.43.0>,<0.44.0>]

timer:243000833

timer:243636514

timer:244753411

timer:245005027

timer:245296405

timer:245356679

timer:245659526

timer:245662159

timer:245731926

timer:245779971

　　从测试结果看，并不是调度器越多越好，也不是越少越好，合适实际应用场景才是最好的。

巴特西

erlang进程概述

一、概述

二、示例

三、进程的调度

最新文章

热门文章