亚洲人av高清无码,亚洲动漫精品无码av天堂,亚洲欧洲日产国码久在线观看

Ruby Fiber指南�Q�五�Q�：实现Actor�Q�兼谈Erlang的process调度

dennis — Tue, 13 Apr 2010 10:31:00 GMT

Ruby Fiber指南�Q�一�Q�基��
    Ruby Fiber指南�Q�二�Q�参��C��?/a>
    Ruby Fiber指南�Q�三�Q�过滤器
    Ruby Fiber指南�Q�四�Q��P代器
    Ruby Actor指南�Q�五�Q�实现Actor

    写这个指南的时候，计划是第五章写一个Fiber的应用例子，但是一时没有想到比较好的例子，模仿《Programming in Lua》中的多��d��下蝲的例子也不合适，因�ؓRuby中的异步HttpClient跟lua�q�是很不一��L��Q�体��C��了Fiber的优炏V��因此，�q�第五节一直拖着没写�?br />     恰��y最�q�在��组中做了一�ơErlang的分享，有�h问到Erlang调度器的实现问题�Q�这块我没注意过�Q�那时候就�Ҏ��我对coroutine实现actor的想法做了下解释�Q�后来思考了下那个解释是错误的，Erlang的调度器是抢占式的，而通过coroutine实现的actor调度却是非抢占的�Q�两者还是截然不同的。我在�?a href="http://m.tkk7.com/killme2008/archive/2010/03/23/316273.html">Actor、Coroutine和Continuation的概忉|��?/a>》中提到coroutine可以实现actor风格�Q�actor跟coroutine�q�没有必然的联系�Q�这��文章的目的��在于证明这一点，使用Ruby Fiber实现一个简单的actor风格的库�Q�整个代码不�?00行。后面还会谈到这个实现的�~�点�Q�以及我对Erlang调度器实现的理解�?br />
    首先是monkey patch�Q�给Thread和Fiber�c�d��上两个方法，分别用于获取当前�U�程的调度器和Fiber对应的actor:

class Thread
  #得到当前�U�程的调度器
  def __scheduler__
    @internal_scheduler||=FiberActor::Scheduler.new
  end
end

class Fiber
  #得到当前Fiber的actor
  def __actor__
    @internal_actor
  end
end

�q�里实现的actor仍然是Thread内的�Q�一个Thread只跑一个调度器�Q�每个actor兌��一个Fiber�?br /> 让我们来��x��调度器该怎么实现,调度器顾名思义��是协调actor的运行，每次挑选适当的actor�q�执行，可以惌��调度器内部应该维护一个等待调度的actor队列�Q�Scheduler每次从队列里取出一个actor�q�执行，执行完之后取下一个actor执行�Q�不断��@环持�l�这个过�E�；在没有actor可以调度的时候，调度器应该让出执行权。因此调度器本��n也是一个Fiber�Q�它内部有个queue�Q�用于维护等待调度的actor�Q?br />

module FiberActor
  class Scheduler
    def initialize
      @queue=[]
      @running=false
    end

    def run
      return if @running
      @running=true
      while true
        #取出队列中的actor�q�执�?/span>
        while actor=@queue.shift
          begin
            actor.fiber.resume
          rescue => ex
            puts "actor resume error,#{ex}"
          end
        end
        #没有��d��Q�让出执行权
        Fiber.yield
      end
    end

    def reschedule
      if @running
        #已经启动�Q�只是被挂�v�Q�那么再�ơ执�?/span>
        @fiber.resume
      else
        #��当前actor加入队列
        self << Actor.current
      end
    end

    def running?
      @running
    end

    def <<(actor)
      #��actor加入�{�待队列
      @queue << actor unless @queue.last == actor
      #启动调度�?/span>
      unless @running
         @queue << Actor.current
         @fiber=Fiber.new { run }
         @fiber.resume
      end
    end
  end
end

run�Ҏ��是核心的调度�Ҏ��Q�注释说明了主要的工作流�E�。因��度器可能让出执行权，因此提供了reschedule�Ҏ��重新resume启动调度器�?lt;<�Ҏ��用于��等待被调度的actor加入�{�待队列�Q�如果调度器没有启动�Q�那么就启动调度Fiber�?br />
有了调度器，Actor的实��C��很简单，Actor跟Fiber是一对一的关�p�，Actor内部�l�护一个mailbox�Q�用来存储接收到的消息。最重要的是receive原语的实玎ͼ�我们�q�里很简单，不搞模式匚w��Q�只是接收消息。receive的工作流�E�大概是�q�样�Q�判断mailbox中有没有消息�Q�有消息的话�Q�取出消息�ƈ调用block处理�Q�没有消息的话就yield让出执行权�?br />

module FiberActor
  class Actor
    attr_accessor :fiber
    #定义�c�L��?/span>
    class << self
      def scheduler
        Thread.current.__scheduler__
      end

      def current
        Fiber.current.__actor__
      end

      #启动一个actor
      def spawn(*args,&block)
        fiber=Fiber.new do
           block.call(args)
        end
        actor=new(fiber)
        fiber.instance_variable_set :@internal_actor,actor
        scheduler << actor
        actor
      end

      def receive(&block)
        current.receive(&block)
      end
    end

    def initialize(fiber)
       @mailbox=[]
       @fiber=fiber
    end

    #�l�actor发送消�?/span>
    def << (msg)
      @mailbox << msg
      #加入调度队列
      Actor.scheduler << self
    end

    def receive(&block)
      #没有消息的时候，让出执行�?/span>
      Fiber.yield while @mailbox.empty?
      msg=@mailbox.shift
      block.call(msg)
    end

    def alive?
      @fiber.alive?
    end
  end

end

Actor.spawn用于启动一个actor�Q�内部其实是创徏了一个fiber�q�包装成actor�l�用��P��每个actor一被创建就加入调度器的�{�待队列�?lt;<�Ҏ��用于向actor传递消息，传递消息后�Q�该actor也将加入�{�待队列�Q�等待被调度�?br />
我们的简化版actor库已�l�写完了�Q�可以尝试写几个例子�Q�最��单的hello world:

include FiberActor

Actor.spawn { puts "hello world!"}

输出�Q?br />

hello world!

没有问题�Q�那么试试传递消息：

actor=Actor.spawn{
Actor.receive{ |msg| puts "receive #{msg}"}
}
actor << :test_message

输出�Q?br />

receive test_message

也成了，那么试试两个actor互相传递消息，乒乓一下下�Q?br />

pong=Actor.spawn do
      Actor.receive do |ping|
        #收到ping�Q�返回pong
        ping << :pong
      end
    end
ping=Actor.spawn do
      #ping一下，��ping作�ؓ消息传�?/span>
      pong << Actor.current
      Actor.receive do |msg|
        #接收到pong
        puts "ping #{msg}"
      end
    end
#resume调度�?/span>
Actor.scheduler.reschedule

输出�Q?br />

ping pong

     都没有问题，�q�个��񔽎�单actor基本完成了。可以看刎ͼ�利用coroutine来实现actor是完全可行的�Q�事实上我这里描�q�的实现基本上是revactor�q�个库的实现原理�?a >revactor是一个ruby的actor库，它的实现��是��Z��Fiber�Q��ƈ且支持消息的模式匚w��和thread之间的actor调度�Q�有兴趣地可以去玩下。更�q�一步，其实采用轻量�U�协�E�来模拟actor风格早就不是新鲜��L��Q�比如在cn-erlounge的第四次会议�?/a>��有两个topic是关于这个，一个是51.com利用��Z��ucontext的实现的�c�erlang�q�程模型�Q�一个是�怸�伟的CERL。可以想见，他们的基本原理跟本文所描述不会有太大差别，那么面对的问题也是一栗��?br />
   采用coroutine实现actor的主要缺点如下：
1、因为是非抢占式�Q�这��p��求actor不能有阻塞操作，��M��d��操作都需要异步化。IO可以使用异步IO�Q�没有os原生支持的就需要利用线�E�池�Q�基本上是一个重复造轮子的�q�程�?br /> 2、异常的隔离�Q�某个actor的异�怸�能媄响到调度器的�q��{�Q�简单的try...catch是不够的�?br /> 3、多核的利用�Q�调度器只能跑在一个线�E�上�Q�无法充分利用多�怼��ѝ�?br /> 4、效率因素，在actor数量剧增的情况下�Q�简单的FIFO的调度策略效率是个瓶颈，��管coroutine的切换已�l�非帔R��效�?br />
    当然�Q�上面提到的�q�些问题�q��无法解决�Q�例如可以��用多�U�程多个调度器，�c�M��erlang smp那样来解军_��个调度器的问题。但是如调度效率�q�样的问题是很难解决的。相反，erlang的actor实现��׃��是通过coroutine�Q�而是自己实现一套类似os的调度程序�?br />     首先明确一点，Erlang的process的调度是抢占式的�Q�而非couroutine的协作式的。其�ơ，Erlang早期版本是只有一个调度器�Q�运行在一个线�E�上�Q�随着erts的发展，现在erlang的调度器已经支持smp�Q�每个cpu兌��一个调度器�Q��ƈ且可以明��指定哪个调度器�l�定到哪个cpu上。第三，Erlang的调度也是采用优先队�?旉��片轮询的方式�Q�每个调度器兌��一�?span id=":2v1">ErtsRunQueue�Q?/span>ErtsRunQueue内部又分��Z��?/span>ErtsRunPrioQueue队列�Q�分别对应high,max和normal,low的优先��Q�其中normal和low��q��一个队列；在Erlang中时间片是以reduction为单位，你可以将reduction理解成一�ơ函数调用，每个被调度的process能执行的reduction�ơ数是有限的。调度器每次都是从max队列开始寻扄��待调度的process�q�执行，当前调度的队列如果�ؓ�I�或者执行的reductions��过限制�Q�那么就降低优先�U�，调度下一个队列�?br />
   从上面的描述可以看出�Q�Erlang优秀的地方不仅在于actor风格的轻量��process�Q�另一个强悍的地方��是它的�c�os的调度器�Q�再加上OTP库的完美支持�Q�这不是一般方案能山寨的�?br />

dennis 2010-04-13 18:31 发表评论

Erlang��介的PPT�Q�达人勿入）

dennis — Mon, 12 Apr 2010 02:45:00 GMT

在小�l�内做的一�ơ分享，基本上是在锋��L��一个PPT的基��上做了一些扩充，对Erlang没有了解�q�的朋友可以看看�?br />

View more presentations from dennis zhuang.

dennis 2010-04-12 10:45 发表评论

Rabbitmq的网�l�层��析

dennis — Sun, 29 Nov 2009 04:00:00 GMT
    最�q�在锋爷的徏议下开始读rabbitmq的源码，锋爷说这个项目已�l�很成熟�Q��ƈ且代码也很有借鉴和学习的意义�Q�在自己写erlang代码之前看看别�h是怎么写的�Q�可以少走弯路，避免��L��一些不好的习惯�Q�学习一些最佛_��c��读了一个星期，�q�个��目果然非常��，代码也写的非常清晰易懂，一些细节的处理上非常��y妙，比如我这里想分��n的网�l�层一节�?br />     Rabbitmq是一个MQ�pȝ��Q�也��是消息中间�Ӟ��它实��C��AMQP 0.8规范�Q�简单来说就是一个TCP的广播服务器。AMQP协议�Q�你可以�c�L��JMS�Q�不�q�JMS仅仅是java领域内的API规范�Q�而AMQP比JMS更进一步，它有自己的wire-level protocol�Q�有一套可�~�程的协议，中立于语�a�。简单介�l�了Rabbitmq之后�Q�进入正题�?br />     Rabbitmq充分利用了Erlang的分布式、高可靠性、�ƈ发等�Ҏ��，首先看它的一个结构图�Q?br />

�q�张囑ֱ��C��Rabbitmq的主要组件和�l��g之间的关�p�，具体到监控树的结构，我画了一张图�Q?br />

    ��层是rabbit_sup supervisor�Q�它臛_��有两个子�q�程�Q�一个是rabbit_tcp_client_sup�Q�用来监控每个connection的处理进�E? rabbit_reader的supervisor;rabbit_tcp_listener_sup是监控tcp_listener�? tcp_acceptor_sup的supervisor�Q�tcp_listener里启动tcp服务器，监听端口�Q��ƈ且通过tcp_acceptor_sup启动N个tcp_accetpor�Q�tcp_acceptor发�vaccept��h��Q�等待客��L��q�接;tcp_acceptor_sup负责监控�q�些acceptor。这张图已经能给你一个大体的印象�?/strong>

    讲完大概�Q�进入细节，说说几个我觉的值的注意的地方：
1�?strong>tcp_accepto.erl,r对于accept采用的是异步方式�Q�利�?strong>prim_inet:async_accept/2�? 法，此模块没有被文档化，是otp库内部��?通常来说没必要��用这一模块�Q�gen_tcp:accept/1已经��_��Q�不�q�rabbitmq是广播程序，因此采用了异步方式。��用async_accept�Q�需要打patch�Q�以使得socket好像我们从gen_tcp:accept/1得到的一��P��

handle_info({inet_async, LSock, Ref, {ok, Sock}},
            State = #state{callback={M,F,A}, sock=LSock, ref=Ref}) ->
    %%�q�里做了patch
    %% patch up the socket so it looks like one we got from
    %% gen_tcp:accept/1
    {ok, Mod} = inet_db:lookup_socket(LSock),
    inet_db:register_socket(Sock, Mod),

    try
        %% report
        {Address, Port}         = inet_op(fun () -> inet:sockname(LSock) end),
        {PeerAddress, PeerPort} = inet_op(fun () -> inet:peername(Sock) end),
        error_logger:info_msg("accepted TCP connection on ~s:~p from ~s:~p~n",
                              [inet_parse:ntoa(Address), Port,
                               inet_parse:ntoa(PeerAddress), PeerPort]),
        %% 调用回调模块�Q�将Sock作�ؓ附加参数
        apply(M, F, A ++ [Sock])
    catch {inet_error, Reason} ->
            gen_tcp:close(Sock),
            error_logger:error_msg("unable to accept TCP connection: ~p~n",
                                   [Reason])
    end,

    %% �l�箋发�v异步调用
    case prim_inet:async_accept(LSock, -1) of
        {ok, NRef} -> {noreply, State#state{ref=NRef}};
        Error -> {stop, {cannot_accept, Error}, none}
    end;
%%处理错误情况
handle_info({inet_async, LSock, Ref, {error, closed}},
            State=#state{sock=LSock, ref=Ref}) ->
    %% It would be wrong to attempt to restart the acceptor when we
    %% know this will fail.
    {stop, normal, State};

2�?strong>rabbitmq内部是��用了多个�q�发acceptor�Q�这在高�q�发下、大量连接情况下有效率优势，�c�M��java现在的nio框架采用多个reactor�c�M���Q�查看tcp_listener.erl:

init({IPAddress, Port, SocketOpts,
      ConcurrentAcceptorCount, AcceptorSup,
      {M,F,A} = OnStartup, OnShutdown, Label}) ->
    process_flag(trap_exit, true),
    case gen_tcp:listen(Port, SocketOpts ++ [{ip, IPAddress},
                                             {active, false}]) of
        {ok, LSock} ->
             %%创徏ConcurrentAcceptorCount个�ƈ发acceptor
            lists:foreach(fun (_) ->
                                  {ok, _APid} = supervisor:start_child(
                                                  AcceptorSup, [LSock])
                          end,
                          lists:duplicate(ConcurrentAcceptorCount, dummy)),
            {ok, {LIPAddress, LPort}} = inet:sockname(LSock),
            error_logger:info_msg("started ~s on ~s:~p~n",
                                  [Label, inet_parse:ntoa(LIPAddress), LPort]),
            %%调用初始化回调函�?br />             apply(M, F, A ++ [IPAddress, Port]),
            {ok, #state{sock = LSock,
                        on_startup = OnStartup, on_shutdown = OnShutdown,
                        label = Label}};
        {error, Reason} ->
            error_logger:error_msg(
              "failed to start ~s on ~s:~p - ~p~n",
              [Label, inet_parse:ntoa(IPAddress), Port, Reason]),
            {stop, {cannot_listen, IPAddress, Port, Reason}}
    end.

�q�里有一个技巧，如果要��@环N�ơ执行某个函数F�Q�可以通过lists:foreach�l�合lists:duplicate(N,dummy)来处理�?br />
lists:foreach(fun(_)-> F() end,lists:duplicate(N,dummy)).

3�?strong>simple_one_for_one�{�略的��?/strong>�Q�可以看到对于tcp_client_sup和tcp_acceptor_sup都采用了simple_one_for_one�{�略�Q�而非普通的one_fo_one�Q�这是�ؓ什么呢�Q?br /> �q�牵扯到simple_one_for_one的几个特点：
1)simple_one_for_one内部保存child是��用dict�Q�而其他策略是使用list�Q�因此simple_one_for_one更适合child频繁创徏销毁、需要大量child�q�程的情况，具体来说例如�|�络�q�接的频�J�接入断开�?br /> 2)使用了simple_one_for_one后，无法调用terminate_child/2 delete_child/2 restart_child/2

3)start_child/2 对于simple_one_for_one来说�Q�不必传入完整的child spect�Q�传入参数list�Q�会自动�q�行参数合�ƈ�?strong>在一个地方定义好child spec之后�Q�其他地方只要start_child传入参数卛_��启动child�q�程�Q�简化child都是同一�c�d��q�程情况下的�~�程�?br />
�? rabbitmq中，tcp_acceptor_sup的子�q�程都是tcp_acceptor�q�程�Q�在tcp_listener中是启动�? ConcurrentAcceptorCount个tcp_acceptor子进�E�，通过supervisor:start_child/2�Ҏ��Q?br />
%%创徏ConcurrentAcceptorCount个�ƈ发acceptor
            lists:foreach(fun (_) ->
                                  {ok, _APid} = supervisor:start_child(
                                                  AcceptorSup, [LSock])
                          end,
                          lists:duplicate(ConcurrentAcceptorCount, dummy)),

注意刎ͼ��q�里调用的start_child只传入了LSock一个参敎ͼ�另一个参数CallBack是在定义child spec的时候传入的�Q�参见tcp_acceptor_sup.erl:
init(Callback) ->
    {ok, {{simple_one_for_one, 10, 10},
          [{tcp_acceptor, {tcp_acceptor, start_link, [Callback]},
            transient, brutal_kill, worker, [tcp_acceptor]}]}}.

Erlang内部自动为simple_one_for_one做了参数合�ƈ�Q�最后调用的是tcp_acceptor的init/2:

init({Callback, LSock}) ->
    case prim_inet:async_accept(LSock, -1) of
        {ok, Ref} -> {ok, #state{callback=Callback, sock=LSock, ref=Ref}};
        Error -> {stop, {cannot_accept, Error}}
    end.

对于tcp_client_sup的情�늱��|��tcp_client_sup监控的子�q�程都是rabbit_reader�c�d��Q�在 rabbit_networking.erl中启动tcp_listenner传入的处理connect事�g的回调方法是�? rabbit_networking:start_client/1:

start_tcp_listener(Host, Port) ->
    start_listener(Host, Port, "TCP Listener",
                   %回调的MFA
                   {?MODULE, start_client, []}).

start_client(Sock) ->
    {ok, Child} = supervisor:start_child(rabbit_tcp_client_sup, []),
    ok = rabbit_net:controlling_process(Sock, Child),
    Child ! {go, Sock},
    Child.

start_client调用了supervisor:start_child/2来动态启动rabbit_reader�q�程�?br />
4�?strong>协议的解析，消息的读�?/strong>�q�部分也非常巧妙�Q�这一部分主要在rabbit_reader.erl中，对于协议的解析没有采用gen_fsm�Q�而是实现了一个��y妙的状态机机制,核心代码在mainloop/4中：
%启动一个连�?br /> start_connection(Parent, Deb, ClientSock) ->
    process_flag(trap_exit, true),
    {PeerAddressS, PeerPort} = peername(ClientSock),
    ProfilingValue = setup_profiling(),
    try
        rabbit_log:info("starting TCP connection ~p from ~s:~p~n",
                        [self(), PeerAddressS, PeerPort]),
         %延时发送握手协�?br />         Erlang:send_after(?HANDSHAKE_TIMEOUT * 1000, self(),
                          handshake_timeout),
        %�q�入��d�@环，更换callback模块�Q�魔法就在这个switch_callback
        mainloop(Parent, Deb, switch_callback(
                                #v1{sock = ClientSock,
                                    connection = #connection{
                                      user = none,
                                      timeout_sec = ?HANDSHAKE_TIMEOUT,
                                      frame_max = ?FRAME_MIN_SIZE,
                                      vhost = none},
                                    callback = uninitialized_callback,
                                    recv_ref = none,
                                    connection_state = pre_init},
                                %%注意到这里，handshake��是我们的回调模块，8��是希望接收的数据长度，AMQP协议头的八个字节�?/strong>
                                handshake, 8))

��法��在switch_callback�q�个�Ҏ��上：
switch_callback(OldState, NewCallback, Length) ->
    %发�v一个异步recv��h��Q�请求Length字节的数�?br />     Ref = inet_op(fun () -> rabbit_net:async_recv(
                              OldState#v1.sock, Length, infinity) end),
    %更新状态，替换ref和处理模�?br />     OldState#v1{callback = NewCallback,
                recv_ref = Ref}.

异步接收Length个数据，如果有，erlang会通知你处理。处理模块是什么概念呢�Q�其实就是一个状态的概念�Q�表�C�当前协议解析进行到哪一步，起一个label的作用，看看mainloop/4中的应用�Q?br />
mainloop(Parent, Deb, State = #v1{sock= Sock, recv_ref = Ref}) ->
    %%?LOGDEBUG("Reader mainloop: ~p bytes available, need ~p~n", [HaveBytes, WaitUntilNBytes]),
    receive
        %%接收到数据，交给handle_input处理,注意handle_input的第一个参数就是callback
        {inet_async, Sock, Ref, {ok, Data}} ->
            %handle_input处理
            {State1, Callback1, Length1} =
                handle_input(State#v1.callback, Data,
                             State#v1{recv_ref = none}),
            %更新回调模块�Q�再�ơ发起异步请求，�q�进入主循环
            mainloop(Parent, Deb,
                     switch_callback(State1, Callback1, Length1));

handle_input有多个分支，每个分支都对应一个处理模块，例如我们刚才提到的握手协议：

%handshake模块�Q�注意到�W�一个参敎ͼ��W�二个参数就是我们得到的数据
handle_input(handshake, <<"AMQP",1,1,ProtocolMajor,ProtocolMinor>>,
             State = #v1{sock = Sock, connection = Connection}) ->
     %��协议是否兼�?br />     case check_version({ProtocolMajor, ProtocolMinor},
                       {?PROTOCOL_VERSION_MAJOR, ?PROTOCOL_VERSION_MINOR}) of
        true ->
            {ok, Product} = application:get_key(id),
            {ok, Version} = application:get_key(vsn),
            %兼容的话�Q�进入connections start�Q�协商参�?br />             ok = send_on_channel0(
                   Sock,
                   #'connection.start'{
                     version_major = ?PROTOCOL_VERSION_MAJOR,
                     version_minor = ?PROTOCOL_VERSION_MINOR,
                     server_properties =
                     [{list_to_binary(K), longstr, list_to_binary(V)} ||
                         {K, V} <-
                             [{"product",     Product},
                              {"version",     Version},
                              {"platform",    "                               {"copyright",   ?COPYRIGHT_MESSAGE},
                              {"information", ?INFORMATION_MESSAGE}]],
                     mechanisms = <<"PLAIN AMQPLAIN">>,
                     locales = <<"en_US">> }),
            {State#v1{connection = Connection#connection{
                                     timeout_sec = ?NORMAL_TIMEOUT},
                      connection_state = starting},
             frame_header, 7};
         %否则�Q�断开�q�接�Q�返回可以接受的协议
        false ->
            throw({bad_version, ProtocolMajor, ProtocolMinor})
    end;

    其他协议的处理也是类��|��通过动态替换callback的方式来模拟状态机做协议的解析和数据的接收�Q�真的很巧妙�Q�让我们体会到Erlang的魅力，FP的魅力�?br />
5、序列图�Q?/strong>
1�Q�tcp server的启动过�E�：

2�Q�一个client�q�接上来的处理过�E�：

    ��结�Q�从上面的分析可以看�?rabbitmq的网�l�层是非常健壮和高效的，通过层层监控�Q�对每个可能出现的风险点都做了考虑�Q��ƈ且利用了prim_net模块做异步IO处理。分层也是很清晰�Q�将业务处理模块隔离到client_sup监控下的子进�E�，��网�l�处理细节和业务逻辑分离。在协议的解析和业务处理上虽然没有采用gen_fsm�Q�但是也实现了一套类似的状态机机制�Q�通过动态替换Callback来模拟状态的变迁�Q�非常��y妙。如果你要实��C��个tcp server�Q�强烈推荐从rabbitmq中扣��个网�l�层�Q�你只需要实现自��q��业务处理模块卛_��拥有一个高效、健壮、分层清晰的TCP服务器�?br />

dennis 2009-11-29 12:00 发表评论

Erlang Web Shell(update)

dennis — Thu, 19 Nov 2009 11:22:00 GMT
update�Q�修复了在linux firefox上不兼容的BUG�?br />
   下午搞了�?a >Erlang web shell�Q�可以在web��面上像eshell那样�q�行交互式的Erlang�~�程�Q�方便学习和��试。这样一来，一�?a >erlwsh��可以服务多个client�Q�只要你有网�l�和��览器，随时随地可以敲上几行erlang看看�l�果。代码很��单，��׃��多说了，有兴��的看看�Q�通过mochiweb的http chunk�~�码�Q�client通过Ajax Post方式提交。眼见�ؓ实，看看�q�行截图�Q?br />

    工程在google code上： http://code.google.com/p/erlwsh/

    安装很简单，首先��保你已�l�安装了Erlang�Q�接下来�Q?br />
svn checkout http://erlwsh.googlecode.com/svn/trunk/ erlwsh-read-only
cd erlwsh-read-only
scripts/install_mochiweb.sh
make
./start.sh
    因�ؓ需要��用mochiweb�Q�所以提供了下蝲�q�自动安装的脚本�Q�这是litaocheng的大作。启动后讉K�� http://localhost:8000/shell 卛_��Q�have fun.

dennis 2009-11-19 19:22 发表评论

dennis — Thu, 27 Sep 2007 08:33:00 GMT
   ets表的底层是由哈希表实现的,不过ordered_set例外,它是由��^衡二叉树实现的�?所以不��是插入�q�是查找,set的效率要比ordered_set�?采用set�q�是ordered_set取决于你的需求，当你需要一个有序的集合�Ӟ��昄��应当采用ordered_set模式�?br />
duplicate_bag要比bag的效率要�? 因�ؓbag要和原来的记录比较是否有相同的记录已�l�插�? 如果数据量很�?相同的记录越�?bag的效率就��差.

一张ets表是由创建它的进�E�所拥有, 当此�q�程调用ets:delete或者进�E�终止的时�? ets表就会被删除.

一般情况下, 插入一个元�l�到一张ets表中, 所有代表这个元�l�的�l�构都会被从process的堆栈中,复制到ets表中; 当查找一条记录时, �l�果tuple从ets表中复制到进�E�的堆栈中�?

但是large binaries却不是这�? 它们被存入自已所拥有的off-heap area中。这个区域可以被多个process,ets�?和binaries所�׃�n。它由引用计数的垃圾回收�{�略��理, �q�个�{�略会跟�t�到底有多少个process/ets�?binaries引用了这个large binaries. 如果引用��Cؓ0的话, 此大型二�q�制数据��׃��被垃圑֛�收掉.

看�v来很复杂, 实际�l�论��是: 两进�E�间发送包含大型binary数据的消息其实费用很�? 往ets表插入binary�c�d��元组也很划算。我们应该尽可能采用binaries来实现字�W�串或无�c�d��的大数据�?

dennis 2007-09-27 16:33 发表评论

Erlang之IO�~�程

dennis — Thu, 27 Sep 2007 08:03:00 GMT
Erlang用于操纵文�gI/O的模块有�Q?br /> file模块�Q�打开、读、写、关闭文件已�l�操作目录的�Ҏ��基本都在�q�里

filename模块�Q�提供��^台独立方式用于操�U�|��件名

filelib模块�Q�file模块的扩展，提供了更多的实用工具�Q�在file模块基础上构�?br />
io模块�Q�一�p�d��用于操作打开的文件的�Ҏ��Q�解析格式、格式化输出�{�等�?br />
1.打开文�g�Q?br /> {ok,F}=file:open("data1.dat",read). %��L��式打开
{ok,F}=file:open("data1.dat",write). %写模�?br /> {ok,F}=file:open("data1.dat",[read,write]). %诅R��写、二�q�制模式

支持的所有模式参见文档�?br />
2.��d��Q?br /> (1)如果以一个Erlang term的方式读取，采用:
io:read(F,'').
其中�W�二个参数是提示�W�，用于在标准输入时作�ؓ提示�?br /> �q�个�Ҏ��有一个变形read/3
read(IoDevice, Prompt, StartLine)
�W�三个参数用于指定开始行数�?br />
(2)如果是按字节��d��Q�文件必��L��raw模式打开采用�Q?br /> {ok, Data}=file:read(F,100).

(3)按行��d��Q?br /> io:get_line(F, '').

(4)��d��整个文�g的内容：
{ok,Binary}=file:read_file("data1.dat").
注意�q�回的是一个binary�c�d��

(5)随机��d��Q?br /> {ok,Binary}=file:pread(F, 22, 46).

其中�W�二个参数是开始位�|�，�W�三个参数是��d��的长度，�q�回的也是binary�c�d��?br />
3.写入文�g�Q?br /> (1)采用io:format/3�Ҏ��Q?br /> {ok, S} = file:open("test2.dat", write).
io:format(S, "~s~n", ["Hello readers"]).
io:format(S, "~w~n", [123]).

其中的~开头的字符是一个个格式化命令，比如常见的：
~c   anscii�?br /> ~f   ��点�?br /> ~s   字符�?br /> ~w   Erlang term
~p   与~w�c�M��Q�不�q�当多行时将自动换行
~n   昄��Q�换行符

�Q?�Q�写入整个文�Ӟ��
file:write_file(File, IO)

其中IO可以为list、integer或者binary�c�d��

�Q?�Q�随机写入：
file:pwrite(F, 10, <<"new">>)

4.关闭文�g:
file:close(F).

5.目录操作�Q?br /> 都是linux命��o风格的操作，
cd("/home/dennis/"). %�q�入目录
file:list_dir(".").   %列出当前目录文�g
file:make_dir("test"). %创徏test目录
file:del_dir("test").   %删除test目录

6.获取文�g信息�Q�比如文件大��，最后修�Ҏ��间等�{�。调用file:read_file_info/1�Ҏ��Q�该�Ҏ��q�回一个file_info记录�c�d��Q�里面拥有文件的具体信息�Q�比如type、size�{��?br /> {ok, Facts} =file:read_file_info(File).
io:format("~s~n",{Facts#file_info.type, Facts#file_info.size}).

7.复制和删除文�Ӟ��
file:copy(Source, Destination).
file:delete(File).

    �q�个�W�记仅仅记录了一些常用到的方法，一些高�U�的工具�Ҏ��q�没有涉及，具体参考Erlang的文档�?br />

dennis 2007-09-27 16:03 发表评论

��单的web server性能��试

dennis — Wed, 29 Aug 2007 10:10:00 GMT
     摘要: ��单的web server性能��试�Q�一般多�U�程方式与采用jdk5�U�程池的比较�?nbsp; 阅读全文

dennis 2007-08-29 18:10 发表评论

Erlang ring benchmark

dennis — Sat, 04 Aug 2007 09:46:00 GMT
    �q�是Programming Erlang�W?章节的一个练习，创徏N个process�Q�连接成一个圈�Q�然后在�q�个圈子里发送消息M�ơ，看看旉��是多��，然后用另一门语�a�写同��L��E�序�Q�看看时间是多少。我自己写的版本在处�?000个进�E�，1000�ơ消息��@环（也就�?00万次消息传递）时花�?�U�多�Q�后来去google别�h写的版本�Q�竟然让我找��C��?8�q�做的benchmark�Q�Erlang vs. java�Q�也是同��L��的问题。测试的�l�果是Erlang性能�q�远大于java�Q�这也是昄��的结果，Erlang的process是轻量��、无�׃�n的，而java的线�E�是os�U�别的，两者创建的cost不可同日而语。详�l�的比较��L��q�里
    不过我分析了�q�个��试里的Erlang代码�Q�存在问题，�q�没有完成所有的循环�Q�进�E�就�l�束了，�q�对比较�l�果有较大的影响。原始代码如下：

-module(zog).

%% This is a test program that first creates N processes (that are
%% "connected" in a ring) and then sends M messages in that ring.
%%
%% - September 1998
%% - roland

-export([start/0, start/1, start/2]).

-export([run/2, process/1]). % Local exports - ouch

start() -> start(16000).

start(N) -> start(N, 1000000).

start(N, M) -> spawn(?MODULE, run, [N, M]).

run(N, M) when N < 1 ->
io:format("Must be at least 1 process~n", []),
0.0;
run(N, M) ->
statistics(wall_clock),

Pid = setup(N-1, self()),

{_,T1} = statistics(wall_clock),
io:format("Setup : ~w s", [T1/1000]),
case N of
1 -> io:format(" (0 spawns)~n", []);
_ -> io:format(" (~w us per spawn) (~w spawns)~n",
[1000*T1/(N-1), N-1])
end,
statistics(wall_clock),

Pid ! M,
K = process(Pid),

{_,T2} = statistics(wall_clock),
Time = 1000*T2/(M+K),
io:format("Run : ~w s (~w us per msg) (~w msgs)~n",
[T2/1000, Time, (M+K)]),

Time.

setup(0, OldPid) ->
OldPid;
setup(N, OldPid) ->
NewPid = spawn(?MODULE, process, [OldPid]),
setup(N-1, NewPid).

process(Pid) ->
receive
M ->
Pid ! M-1,
if
M < 0 -> -M;
true -> process(Pid)
end
end.
我将process修改一�?/span>�Q?br>
process(Pid) ->
receive
M ->
Pid ! M-1,
io:format("form ~w to ~w~n",[self(),Pid]),
if
M < 0 -> -M;
true -> process(Pid)
end
end.
然后执行下zog:run(3,3)�Q?span style="font-weight: bold;">你将发现消息�l�了两圈��q��束了�Q�第三圈�Ҏ��没有�q�行�Q�不知道��试者是什么用意�?span style="font-weight: bold;">依照现在的执�?00万次消息传送竟然只需�?毫秒�Q�我修改了下了下代码如下�Q?br>-module(zog).

%% This is a test program that first creates N processes (that are
%% "connected" in a ring) and then sends M messages in that ring.
%%
%% - September 1998
%% - roland
-export([start/0, start/1, start/2]).

-export([run/2, process/2]).                    % Local exports - ouch

start() -> start(16000).

start(N) -> start(N, 1000000).

start(N, M) -> spawn(?MODULE, run, [N, M]).

run(N, M) when N < 1 ->
    io:format("Must be at least 1 process~n", []),
    0.0;
run(N, M) ->
    statistics(wall_clock),
    Limit=N-N*M+1+M,
    Pid = setup(N-1,Limit,self()),

    {_,T1} = statistics(wall_clock),
    io:format("Setup : ~w s", [T1/1000]),
    case N of
        1 -> io:format(" (0 spawns)~n", []);
        _ -> io:format(" (~w us per spawn) (~w spawns)~n",
                       [1000*T1/(N-1), N-1])
    end,
    statistics(wall_clock),
% io:format("run's Pid=~w~n",[Pid]),
    Pid ! M,
    K = process(Pid,Limit),
% io:format("run's K=~w~n",[K]),

    {_,T2} = statistics(wall_clock),
    Time = 1000*T2/(M+K),
    io:format("Run   : ~w s (~w us per msg) (~w msgs)~n",
              [T2/1000, Time, (M+K)]),
T2/1000.

setup(0,Limit, OldPid) ->
    OldPid;
setup(N,Limit, OldPid) ->
    NewPid = spawn(?MODULE, process, [OldPid,Limit]),
    setup(N-1, Limit,NewPid).

process(Pid,Limit) ->
    receive
        M ->
            Pid ! M-1,
         %   io:format("from ~w to ~w and M=~w~n",[self(),Pid,M]),
            if
                M -M;
                true   -> process(Pid,Limit)
            end
    end.
修改之后�Q�执行zog:run(3000,1000�Q�，也就�?000个进�E�，1000�ơ消息��@环，��d��300万次消息传递，�l�果�?.5�U�左叻I��q�也是相当惊人的�l�果。有人用haskell和scheme各实��C��一个版本，有兴��的看看�q�里�?a >�q�里

dennis 2007-08-04 17:46 发表评论

dennis — Tue, 24 Jul 2007 03:23:00 GMT
    暂时搞不到《Programming Erlang》，最�q�就一直在看Erlang自带的例子和Reference Manual。基��语法斚w��有一些过去遗漏或者没有注意的�Q�断断箋�l�仅��C��此�?br>
1。Erlang的保留字有：

after and andalso band begin bnot bor bsl bsr bxor case catch cond div end fun if let not of or orelse query receive rem try when xor
基本都是些用于逻辑�q�算、位�q�算以及�Ҏ��表达式的�W�号

2.Erlang的类�?/span>�Q�除了在前面入门一提到的类型外�Q�还包括�Q?br>1)Binary�Q�用于表�C�某�D�|��知类型的内存区域
比如�Q?br>1> <<10,20>>.
<<10,20>>
2> <<"ABC">>.
<<65,66,67>>

2�Q�Reference�Q�通过调用mk_ref/0产生的运行时的unique term

3)String�Q�字�W�串�Q�Erlang中的字符串用双引号包括�v来，其实也是list。编译时期，两个邻近的字�W�串��被�q�接��h��Q�比�?string" "42" �{��h�?"string42"

4)Record�Q�记录类型，与c语言中的struct�c�M��Q�模块可以通过-record属性声明，比如�Q?br>-module(person).
-export([new/2]).
-record(person, {name, age}).
new(Name, Age) ->
   #person{name=Name, age=Age}.
1> person:new(dennis, 44).
{person,dennis,44}
在编译后其实已经被�{化�ؓtuple。可以通过Name#person.name来访问Name Record的name属性�?br>
3.模块的预定义属�?/span>�Q?br>-module(Module).    声明模块名称�Q�必��M��文�g名相�?br>-export(Functions).   指定向外界导出的函数列表
-import(Module,Functions).   引入函数�Q�引入的函数可以被当作本地定义的函数使用
-compile(Options).     讄��~�译选项�Q�比如export_all
-vsn(Vsn).         模块版本�Q�设�|�了此项�Q�可以通过beam_lib:version/1 获取此项信息
可以通过-include�?include_lib来包含文�Ӟ��两者的区别是include-lib不能通过�l�对路径查找文�g�Q�而是在你当前Erlang的lib目录�q�行查找�?br>
4.try表达�?/span>�Q�try表达式可以与catch�l�合使用�Q�比如：

try Expr
catch
throw:Term -> Term;
exit:Reason -> {'EXIT',Reason}
error:Reason -> {'EXIT',{Reason,erlang:get_stacktrace()}}
end

不仅如此�Q�try�q�可以与after�l�合使用�Q�类似java中的try..finally�Q�用于进行清除作用，比如�Q?br>termize_file(Name) -> {ok,F} = file:open(Name, [read,binary]), try {ok,Bin} = file:read(F, 1024*1024), binary_to_term(Bin) after file:close(F) end.

5.列表推断�Q�List Comprehensions�Q�，函数式语�a��Ҏ��之一�Q�Erlang中的语法�c�M��Q?br>[Expr || Qualifier1,...,QualifierN] Expr可以是�Q意的表达式，而Qualifier是generator或者filter。还是各举例子说明下�?br>1> [X*2 || X <- [1,2,3]]. [2,4,6]

2> L=[1,2,3,4,5,6,7].
[1,2,3,4,5,6,7]

3> [X|X<-L,X>=3].
[3,4,5,6,7]

再看几个比较��L��例子�Q�来自Programming Erlang�Q?br>比如快速排�?/span>�Q?br>-module(qsort).
-export([qsort/1]).
qsort([])->[];
qsort([Pivot|T])->
qsort([X||X<-T,X   ++ [Pivot] ++
qsort([X||X<-T,X>=Pivot]).

搜烦勾股数组�Q?br>%勾股数组
-module(pythag).
-export([pythag/1]).
pythag(N)->
    L=lists:seq(1,N),
    Square=fun(X) when is_number(X)->X*X end,
    [{A,B,C}||
        A<-L,
        B<-L,
        C<-L,
        A+B+C=        Square(A)+Square(B)=:=Square(C)].
列表推断��大大减��你的敲击键盘的�ơ数�?br>
6.�?/span>�Q�定义常量或者函数等�{�，语法如下�Q?br>-define(Const, Replacement). -define(Func(Var1,...,VarN), Replacement).
使用的时候在宏名前加个问��P��Q�比�?Const�Q�Replacement��插入宏出现的位�|�。系�l�预定义了一些宏:
?MODULE 表示当前模块�?br> ?MODULE_STRING 同上�Q�但是以字符串�Ş�?br>?FILE 当前模块的文件名
?LINE 调用的当前代码行�?br>?MACHINE 机器�?br>
Erlang的宏与C语言的宏很相��|��同样有宏指示�W�，包括�Q?br>
-undef(Macro).
取消宏定�?
-ifdef(Macro).
当宏Macro有定义的时候，执行以下代码
-ifndef(Macro).
同上�Q�反�?
-else.
接在ifdef或者ifndef之后�Q�表�C�Z��满��前者条件时执行以下代码
-endif.
if�l�止�W?/dd>
假设�?define(Square(X),X*X).用于计算�q�x��Q�那�??X��返回X表达式的字符串�Ş式，�c�M��C语言�?arg

一个简单的宏例子：

-module(macros_demo).
-ifdef(debug).
-define(LOG(X), io:format("{~p,~p}: ~p~n", [?MODULE,?LINE,X])).
-else.
-define(LOG(X), true).
-endif.
-define(Square(X),X*X).
-compile(export_all).
test()->
    A=3,
    ?LOG(A),
    B=?Square(A),
    io:format("square(~w) is ~w~n",[A,B]).
当编译时不开启debug选项的时候：
17> c(macros_demo).
{ok,macros_demo}
18> macros_demo:test().
square(3) is 9

当编译时开启debug之后�Q?br>
19> c(macros_demo,{d,debug}).
{ok,macros_demo}
20> macros_demo:test().
{macros_demo,11}: 3
square(3) is 9
ok

可以看到LOG的输��Z��Q�行数、模块名以及参数
7�?span style="font-weight: bold;">Process Dictionary�Q�每个进�E�都有自��q��process dictionary�Q�用于存储这个进�E�内的全局变量�Q�可以通过下列
BIFs操作�Q?br>put(Key, Value)
get(Key)
get()
get_keys(Value)
erase(Key)
erase()

8、关于分布式�~�程�Q�需要补充的几点
1�Q�节点之间的�q�接默认是transitive�Q�也��是当节点A�q�接了节点B�Q�节点B�q�接了节点C�Q�那么节点A也与节点C互相�q�接
可以通过启动节点时指定参�?connect_all false来取消默认行�?br>
2�Q�隐藏节点，某些情况下，你希望连接一个节点而不去连接其他节点，你可以通过在节点启动时指定-hidden选项
来启动一个hidden node。在此情况下�Q�通过nodes()查看所有连接的节点��不会出现隐藏的节点�Q�想看到隐藏的节�?br>可以通过nodes(hidden)或者nodes(connected)来查看�?br>
完整的erl选项如下�Q?br>

-connect_all false 上面已经解释�?

-hidden 启动一个hidden node

-name Name 启动一个系�l�成��点，使用long name.

-setcookie Cookie �?code>Erlang:set_cookie(node(), Cookie).相同�Q�设�|�magic cookie

-sname Name 启动一个Erlang�pȝ��作�ؓ节点�Q��用short name

注意,short name启动的节�Ҏ��无法与long name节点通信�?/span>�?br>
9.一个小�l�节�Q�在Erlang中小于等于是�?<表示�Q�而不是一般语�a�中的<=语法�Q�我犯过错误的地方，同样�Q�不�{�于都是�?��P��而不�?/span>
!,比如/=�?/=�?/span>

10.and or 和andalso orelse的区�?/span>

and和or会计��两边的表达式，而andalso和orelse的求值采用短路机�Ӟ��比如exp1 andalso exp2�Q�当exp1�q�回false之后�Q�就不会��L��?br>exp2�Q�而是直接�q�回false�Q�而exp1 and exp2会对exp1和exp2都进行求��|��or与orelse也类伹{�?br>
今天�?a >erlang-china下到了《Programming Erlang》，准备打印一份看看，�q�入OTP的学习�?

dennis 2007-07-24 11:23 发表评论

dennis — Sun, 15 Jul 2007 08:11:00 GMT
    Lich Ray写了个帖子�?a >函数式编�E�语�a�曲高和寡�Q?/a>》，用快速排序的例子来说明函数式�~�程在表达思想斚w��比命令式语言更容易，其实�q�一�Ҏ��庸置疑，如果你正在读或者读�q�SICP的话。文中给了haskell、scheme和javascript的实��C��子，我也凑趣写了个Erlang版本�Q�haskell我不了解��׃��说了�Q�其他实现分别如下：
scheme�Q?br>
(define (qsort ls)
     (if (null? ls) '()
         (let
             ((x (car ls))
             (xs (cdr ls)))
             (let
                 ((lt (filter (lambda (y) (< y x)) xs))
                 (st (filter (lambda (y) (>= y x)) xs)))
                 (append (qsort lt) (list x) (qsort st))))))

javascript:

    // 把要用到的表辑ּ�抽象出来
    Array.prototype.head = function () {
        return this[0];
    }

    Array.prototype.tail = function () {
        return this.slice(1);
    }

   Array.prototype.filter = function (proc) {
       var tmpArr = [];
       for (var i = 0; i < this.length; i++)
       if (proc(this[i]) == true)
           tmpArr.push(this[i]);
       return tmpArr;
   }
   Array.prototype.qsort = function () {
       if (this == false) return []
        var x, xs, lt, st
       x = this.head()
        xs = this.tail()
        lt = xs.filter(function (y) {return y < x})
        st = xs.filter(function (y) {return y >= x})
        return lt.qsort().concat([x], st.qsort())
    }
用Erlang的话�Q�Erlang的list其实跟scheme的list是一��L��Q�甚臌��定义的基本高阶函数都一��P��map,filter�Q�append�{�等,利用lists模块提供的filter和append�Q�我们可以写出：

    qsort([])->[];
    qsort([H|T])->
        Lt=lists:filter(fun(E)->E<H end,T),
        St=lists:filter(fun(E)->E>=H end,T),
    lists:append(qsort(Lt),lists:append([H],qsort(St))).
我们来比较下scheme和Erlang版本�Q�两者最显著的不同是�Q�scheme使用了条件语句if�Q�而Erlang却是通过模式匚w��来代替条件分支判断。同��P��在list的分解上面，Erlang也是利用了规则匹配来代替car,cdr函数�Q�从�q�里可以看出规则匚w��在Erlang中的主要作用�Q�分解复杂数据结构以便赋值和条�g分支的分�z��?br>    扯远些可以谈到模式匹配是�?#8220;like-a”来代替消息分�z�֜�传统命��o式语�a�中严格的“is-a”�Q�这也跟现实世界的情冉|��为符合，现实世界中我们对事物的判断都是模�p�。而这一点，不正�?#8220;Duck-Typing”�Q�传�l�语�a�对于对象的类�?type)判断来源于严格确定对象是什么类�Q�class�Q�，不是�q�个�c�d��没有相应的�Ҏ��Q�而事实上�c�M��c�d��q�两个概念�ƈ不是一致的�Q�对象的�c�d��更应该根据对象能够做什么来军_��。扯�q�了�Q�这只是我读�?a >��p��的链�?/a>》得来的感受�Q�如果对模式匚w��q�有怀疑的话，让我们回到这个例子的Erlang版本�Q�代码中我们调用了两�ơfilter�q�行全表扫描�Q�以便得到根据H切割的大��两个部分，�q�在性能上有不小的媄响，那么我们能不能只�q�行一�ơ全表扫描呢�Q�返回结果是“大小”两个部分�Q�看看Erlang应该怎么写：

sort([]) -> [];
sort([Pivot|Rest]) ->
   {Smaller, Bigger} = split(Pivot, Rest),
   lists:append(sort(Smaller), [Pivot|sort(Bigger)]).
split(Pivot, L) ->
split(Pivot, L, [], []).
split(Pivot, [], Smaller, Bigger) ->
{Smaller,Bigger};
split(Pivot, [H|T], Smaller, Bigger) when H < Pivot ->
split(Pivot, T, [H|Smaller], Bigger);
split(Pivot, [H|T], Smaller, Bigger) when H >= Pivot ->
split(Pivot, T, Smaller, [H|Bigger]).

    �q�几行代码充分展��C��模式匚w��的威力，不过Erlang其实有内�|�的�Ҏ��partition用于切割list的，�q�里只是��Z��展现模式匚w��Q�因此上面的代码可以改�ؓ�Q?br>
sort([]) -> [];
sort([Pivot|Rest]) ->
{Smaller, Bigger} = lists:partition(fun(E)->E<Pivot end, Rest),
lists:append(sort(Smaller), [Pivot|sort(Bigger)]).

同样的代码改写�ؓruby版本�Q?br>
def qsort(array)
arr=array.dup
  if arr==[]
    []
  else
    x=arr.shift
    smaller,bigger=arr.partition{|e| e<=x}
    qsort(smaller)+[x]+qsort(bigger)
  end
end
    ruby与Erlang都有�q�行赋��|��但是ruby不支持模式匹配。请注意ruby�q�没有尾递归优化�Q�因此上面的代码在数�l�比较大的时候会��D��栈溢出，想用ruby做函数式�~�程应该��量多��用��@环和map,filter,collect�{�辅助高阶函数�?br>    另外一个Erlang与ruby、scheme比较重要的区别是Erlang的变量只能赋��g��ơ（或者说�l�定�Q�，也就是single assignment。这个特点与Erlang所要满��的�q�行场景有紧密关�p�，当系�l�发生错误时�Q�就可以从原来的值重新启动�Q务，而不用担心由于变量值的变化��D��pȝ��恢复困难�?br>

dennis 2007-07-15 16:11 发表评论

Erlang分布式在linux和windows上的注意事项

dennis — Fri, 29 Jun 2007 08:33:00 GMT
    没事做，��在两台机器间测试下Erlang分布式的例子�Q�一个台是windowsXP�Q�一台装的redHat9�Q�没有详�l�的文档�Q�自己摸索着搞成功了�Q�记录下�?br>
1.首先,分布式Erlang的实现提供了自有的安全机制来预防未经授权的Erlang�pȝ��讉K��。Erlang�pȝ��与别的机器进行交互时必须有同��L��magic cookie,保存在一个称�?erlang.cookie的文件中�Q��ؓ了在两台不同机器间测试，需要编辑一�?erlang.cookie,内容随便�Q�比如：
just_test

然后��这份文件拷贝到windows环境变量HOMEPATH所在的目录 �Q�比如我的是C:\Documents and Settings\Admin�Q�而linux拯��到环境变�?HOME指向的目录，比如我这里是/root。特别注意一点，linux�?erlang.cookie文�g需要设�|�权限�ؓ-r--------�Q�也��是400�Q�仅所有者可读：
chmod 400 .erlang.cookie

2.因�ؓErlang中的node名称是name@host�Q�host是计��机名，因此在两台机器上都需要将计算机名和ip加进hosts文�g�Q�这个文件在linux下是�?etc/hosts�Q�你可以用vi�~�辑如下�Q?br>
127.0.0.1  localhost localhost
x.x.x.x    zane      zane   #windows机器的ip和计��机�?/span>
�Q�hosts在windows�pȝ��的C:\WINDOWS\system32\drivers\etc目录下，�~�辑�Q?br>
127.0.0.1       localhost
x.x.x.x   dennis #linux机器的名�U�和ip

3.�W�三步，要启动节点，通过命��oerl -sname 或者erl -name�Q�在此之前需要启动epmd�q�程�Q�它负责映射�W�号名到机器地址
在两个机器都执行�Q?br>epmd -daemon

4.��x��配置完成�Q�可以测试下Erlang分布式编�E�在不同的机器和�pȝ��之间了（比如�?a href="http://m.tkk7.com/killme2008/archive/2007/06/15/124547.html">Erlang入门(�?--分布式编�E?/a>》中的ping pong例子�Q�，very cool!

dennis 2007-06-29 16:33 发表评论

dennis — Mon, 25 Jun 2007 09:10:00 GMT
     摘要:     ��M��福州，事情没搞定，托给同学帮忙处理了，回家休息了两天就来上班了。回家这几天最大的收获是第四次重读《深入Java虚拟机》，以前不大明了的章节豁然开朗，有种开�H�的感觉�Q�水到渠成，看来技术的学习�q�是急不来�?nbsp;   闲话不提�Q��l�Erlang的学习，上次学习到分布式�~�程的章节，剩下三章分别是错误处理、构造健壮的�pȝ��和杂��，错误处理�?..  阅读全文

dennis 2007-06-25 17:10 发表评论

Erlang入门�Q�三�Q�——分布式�~�程

dennis — Fri, 15 Jun 2007 09:33:00 GMT
    明天要回家一个星期了�Q�好好休息下。今天找到别人翻译的Erlang�~�程手册�Q�值的好好��M��遍�?br />     所谓分布式的Erlang应用是运行在一�p�d��Erlang节点�l�成的网�l�之上。这��L��pȝ��的性质与单一节点上的Erlang�pȝ��q�没有什么不同。分布式�q�是�?#8220;大词”�Q�Erlang从语�a�原生角度支持分布式编�E�，相比于java��单不��?br /> 一、分布式机制
下列的BIFs是用于分布式�~�程�Q?br /> spawn(Node, Mod, Func, Args)
启动�q�程节点的一个进�E?br />
spawn_link(Node, Mod, Func, Args)
启动�q�程节点的一个进�E��ƈ创徏�q�接到该�q�程

monitor_node(Node, Flag)
如果Flag是true,�q�个函数��调用�Q�该函数�Q�的�q�程可以监控节点Node。如果节点已�l�舍弃或者�ƈ不存在，调用的进�E�将收到一个{nodedown,Node}的消息。如果Flag是false,监控��被关闭

node()
�q�回我们自己的进�E�name

nodes()
�q�回其他已知的节点name列表

node(Item)
�q�回原来Item的节点名�U�ͼ�Item可以是Pid,引用�Q�reference�Q�或者端�?port)

disconnect_node(Nodename)
从节点Nodename断开�?br />
节点是分布式Erlang的核心概��c��在一个分布式Erlang应用中，术语�Q�term)节点(node�Q�意味着一个可以加入分布式transactions的运行系�l�。通过一个称为net kernal的特�D�进�E�，一个独立的Erlang�pȝ��可以成�ؓ一个分布式Erlang�pȝ��的一部分。当net kernal�q�程启动的时候，我们�U�系�l�是alive的�?br />
与远�E�节点上的进�E�进行通信�Q�与同一节点内的�q�程通信只有一点不同：

   {Name, Node} ! Mess.
昄��Q�需要接收方增加一个参数Node用于指定接受�q�程所在的节点。节点的name一般是用@隔开的atom�c�d��Q�比如pong@dennis�Q�表�C��机名�ؓdennis上的pong节点。通过执行:

erl -sname pong
��在执行的计��机中创��Z��个节点pong。�ؓ了运行下面的例子�Q�你可能需要两台计��机�Q�如果只有一収ͼ�只要同时开两个Erlang�pȝ��q�以不同的节点名�U�运行也可以�?br />
二、一些例子�?br />     �q�个例子完全来自上面提到的翻译的�q�接�Q�关于分布式�~�程的章节。我增加了截囑֒�说明�?br /> 首先是代码：

-module(tut17).

-export([start_ping/1, start_pong/0,  ping/2, pong/0]).

ping(0, Pong_Node) ->
    {pong, Pong_Node} ! finished,
    io:format("ping finished~n", []);

ping(N, Pong_Node) ->
    {pong, Pong_Node} ! {ping, self()},
    receive
        pong ->
            io:format("Ping received pong~n", [])
    end,
    ping(N - 1, Pong_Node).

pong() ->
    receive
        finished ->
            io:format("Pong finished~n", []);
        {ping, Ping_PID} ->
            io:format("Pong received ping~n", []),
            Ping_PID ! pong,
            pong()
    end.

start_pong() ->
    register(pong, spawn(tut17, pong, [])).

start_ping(Pong_Node) ->
    spawn(tut17, ping, [3, Pong_Node]).

    代码是创��Z��个相互通信的进�E�，�怺�发送消息�ƈ通过io昄��在屏�q�上�Q�本来是一个单一�pȝ��的例子，现在我们让两个进�E�运行在不同的两个节点上。注意start_ping�Ҏ��Q�创建的�q�程调用ping�Ҏ��Q�ping�Ҏ��有两个参敎ͼ�一个是发送消息的�ơ数�Q�一个就是远�E�节点的name了，也就是我们将要创建的�q�程pong的所在节炏V��start_pong创徏一个调用函数pong的进�E�，�q�注册�ؓ名字pong�Q�因此在ping�Ҏ��中可以直接发送消息给pong)�?br />     我是在windows机器上测试，首先打开两个cmd�H�口�Q��ƈcd到Erlang的安装目录下的bin目录�Q�比如C:\Program Files\erl5.5.3\bin,��上面的�E�序存�ؓtut17.erl�Q��ƈ拯��到同一个目录下。我们将创徏两个节点�Q�一个叫ping@dennis,一个叫pong@dennis,其中dennis是我的机器名。见下图�Q?br />
采用同样的命�?br />
erl -sname ping
创徏ping节点。然后在pong节点下执行start_pong()�Q?br />

OK,�q�样��在节点pong上启动了pong�q�程�Q�然后在ping节点调用start_ping�Q�传入参数就是pong@dennis

tut17:start_ping(pong@dennis).
执行�l�果如下图：

同样在pong节点上也可以看到�Q?br />

    �l�果如我们预期的那样�Q�不同节点上的两个进�E�相互通信如此��单。我们给模块tut17增加一个方法，用于启动�q�程�q�程�Q�也��是调用spawn(Node,Module,Func,Args)�Ҏ��Q?br />
start(Ping_Node) ->
    register(pong, spawn(tut17, pong, [])),
    spawn(Ping_Node, tut17, ping, [3, node()]).
pong�q�程启动Ping_Node节点上的�q�程ping。具体结果不再给出�?br />



dennis 2007-06-15 17:33 发表评论

dennis — Thu, 14 Jun 2007 09:12:00 GMT
    Erlang中的process——进�E�是轻量�U�的�Q��ƈ且进�E�间无共享。查了很多资料，��g��没�h说清楚轻量��q�程��是什么概念，�l�箋查找中。。。闲话不提，�q�入�q�发�~�程的世界。本文算是学习笔讎ͼ�也可以说是《Concurrent Programming in ERLANG》第五张的简略翻译�?
1.�q�程的创�?/span>
    �q�程是一�U�自包含的、分隔的计算单元�Q��ƈ与其他进�E��ƈ发运行在�pȝ��中，在进�E�间�q�没有一个��承体�p�，当然�Q�应用开发者可以设计这样一个��承体�p�R�?br>    �q�程的创��Z��用如下语法：

Pid = spawn(Module, FunctionName, ArgumentList)

spawn接受三个参数�Q�模块名�Q�函数名以及参数列表�Q��ƈ�q�回一个代表创建的�q�程的标识符�Q�Pid�Q��?br>如果在一个已知进�E�Pid1中执行：

Pid2 = spawn(Mod, Func, Args)
那么�Q�Pid2仅仅能被Pid1可见�Q�Erlang�pȝ��的安全性就构徏在限制进�E�扩展的基础上�?br>
2.�q�程间通信
    Erlang�q�程间的通信只能通过发送消息来实现�Q�消息的发送��?�W�号�Q?br>
Pid ! Message
    其中Pid是接受消息的�q�程标记�W�，Message��是消息。接受方和消息可以是��M��的有效的Erlang�l�构�Q�只要他们的�l�果�q�回的是�q�程标记�W�和消息�?br>    消息的接受是使用receive关键字，语法如下�Q?br>
receive
      Message1 [when Guard1] ->
          Actions1 ;
      Message2 [when Guard2] ->
          Actions2 ;

end

    每一个Erlang�q�程都有一�?#8220;邮箱”�Q�所有发送到�q�程的消息都按照到达的顺序存储在“邮箱”里，上面所�C�的消息Message1,Message2�Q�当它们�?#8220;邮箱”里的消息匚w��Q��ƈ且约束（Guard�Q�通过�Q�那么相应的ActionN��执行，�q�且receive�q�回的是ActionN的最后一条执行语句的�l�果。Erlang�?#8220;邮箱”里的消息匚w��是有选择性的�Q�只有匹配的消息��被触发相应的Action�Q�而没有匹配的消息��仍然保留在“邮箱”里。这一机制保证了没有消息会��d��其他消息的到达�?br>    消息到达的顺序�ƈ不决定消息的优先�U�，�q�程��轮��检�?#8220;邮箱”里的消息�q�行��试匚w��。消息的优先�U�别下文再讲�?br>
    如何接受特定�q�程的消息呢�Q�答案很��单，��发送方(sender)也附送在消息当中�Q�接收方通过模式匚w��军_��是否接受�Q�比如：

Pid ! {self(),abc}
�l�进�E�Pid发送消息{self(),abc}�Q�利用self�q�程得到发送方作�ؓ消息发送。然后接收方�Q?br>
receive
{Pid1,Msg} ->

end
通过模式匚w��军_��只有Pid1�q�程发送的消息才接受�?br>
3.一些例�?/span>
    仅说明下书中计数的进�E�例�?我添加了��单注释：

-module(counter).
-compile(export_all).
% start()�Q�返回一个新�q�程�Q�进�E�执行函数loop
start()->spawn(counter, loop,[0]).
% 调用此操作递增计数
increment(Counter)->
    Counter!increament.
% �q�回当前计数�?br>value(Counter)->
    Counter!{self(),value},
    receive
        {Counter,Value}->
            %�q�回�l�调用方
            Value
        end.
  %停止计数
stop(Counter)->
     Counter!{self(),stop}.
loop(Val)->
     receive
         %接受不同的消�?/span>�Q�决定返回结�?br>         increament->
             loop(Val+1);
         {From,value}->
             From!{self(),Val},
             loop(Val);
         stop->
             true;
         %不是以上3�U�消�?/span>�Q�就�l�箋�{�待
         Other->
             loop(Val)
      end.




调用方式�Q?br>
1> Counter1=counter:start().
<0.30.0>
2> counter:value(Counter1).
0
3> counter:increment(Counter1).
increament
4> counter:value(Counter1).
1

��Z��q�程的消息传递机制可以很�Ҏ��地实现有限状态机�Q�FSM�Q�，状态��用函数表�C�，而事件就是消息。具体不再展开

4.��时讄��
    Erlang中的receive语法可以��d��一个额外选项�Q�timeout�Q�类��|��

receive
   Message1 [when Guard1] ->
     Actions1 ;
   Message2 [when Guard2] ->
     Actions2 ;

   after
      TimeOutExpr ->
         ActionsT
end

after之后的TimeOutExpr表达式返回一个整数time�Q�毫�U��别）�Q�时间的�_��E�度依赖于Erlang在操作系�l�或者硬件的实现。如果在time毫秒内，没有一个消息被选中�Q�超时设�|�将生效�Q�也��是ActionT��执行。time有两个特�D��|��
1)infinity(无穷�?�Q�infinity是一个atom�Q�指定了��时讄��永�q�不会被执行�?br>2) 0�Q�超时如果设定�ؓ0意味着��时讄��立��L��行，但是�pȝ��首先尝试当�?#8220;邮箱”里的消息�?br>
    ��时的常见几个应用，比如挂�v当前�q�程多少毫秒�Q?br>
sleep(Time) ->
  receive
    after Time ->
    true
end.
比如清空�q�程�?#8220;邮箱”,丢弃“邮箱”里的所有消息：

flush_buffer() ->
  receive
    AnyMessage ->
      flush_buffer()
  after 0 ->
    true
end.
    ��当前进�E�永�q�挂��P��

suspend() ->
    receive
    after
        infinity ->
            true
    end.
    ��时也可以应用于实现定时器，比如下面�q�个例子�Q�创��Z��个进�E�，�q�个�q�程��在讑֮�旉��后向自己发送消息：

-module(timer).
-export([timeout/2,cancel/1,timer/3]).
timeout(Time, Alarm) ->
   spawn(timer, timer, [self(),Time,Alarm]).
cancel(Timer) ->
   Timer ! {self(),cancel}.
timer(Pid, Time, Alarm) ->
   receive
    {Pid,cancel} ->
       true
   after Time ->
       Pid ! Alarm
end.


5、注册进�E?/span>
    ��Z��l�进�E�发送消息，我们需要知道进�E�的Pid�Q�但是在某些情况下：在一个很大系�l�里面有很多的全局servers�Q�或者�ؓ了安全考虑需要隐藏进�E�Pid。�ؓ了达到可以发送消息给一个不知道Pid的进�E�的目的�Q�我们提供了注册�q�程的办法，�l�进�E�们注册名字�Q�这些名字必��L��atom�?br>    基本的调用�Ş式：

register(Name, Pid)
��Name与进�E�Pid联系��h��

unregister(Name)
取消Name与相应进�E�的对应关系�?br>
whereis(Name)
�q�回Name所兌��的进�E�的Pid�Q�如果没有进�E�与之关联，��p��回atom:undefined

registered()
�q�回当前注册的进�E�的名字列表

6.�q�程的优先��
讑֮��q�程的优先��可以使用BIFs:
process_flag(priority, Pri)

Pri可以是normal、low,默认都是normal
优先�U�高的进�E�将相对低的执行多一炏V�?br>
7.�q�程�l�（process group)
    所有的ERLANG�q�程都有一个Pid与一个他们共有的�U�CؓGroup Leader相关联，当一个新的进�E�被创徏的时候将被加入同一个进�E�组。最初的�pȝ��q�程的Group Leader��是它自�w�，因此它也是所有被创徏�q�程及子�q�程的Group Leader。这��意味着Erlang的进�E�被�l�织��Z��Tree�Q�其中的根节点就是第一个被创徏的进�E�。下面的BIFs被用于操�U�进�E�组�Q?br>group_leader()
�q�回执行�q�程的Group Leader的Pid
group_leader(Leader, Pid)
讄��q�程Pid的Group Leader��E�的Leader

8.Erlang的进�E�模型很�Ҏ��L��建Client-Server的模型，书中有一节专门讨��Z��q�一点，着重强调了接口的设计以及抽象层�ơ的隔离问题�Q�不��译了�?br>

dennis 2007-06-14 17:12 发表评论

dennis — Thu, 14 Jun 2007 01:28:00 GMT

Erlang前世今生

1982 - 1985
我们使用�?> 20�U�语�a��q�行了电信行业的�~�程实验�Q�结论是�Q�这��L��语言需要是一门高度的抽象的语�a�才能辑ֈ�生��力目标�?�l�我们留下印象的有：List,Prolog,Parlog ...)
1985 - 86
我们使用Lisp,Prolog,Parlog�{�语�a��q�行了实验，�l�论是：�q�样的语�a�需要原生支持的�q�发控制和容错处理，�q�且执行模型必须没有使用回溯。（排除了List和Prolog.) 而且它必��L��有�ƈ发粒度比如一个异步的电话�q�程可以用语�a�的一个进�E�表�C�（排除了Parlog�Q�。最后我们不得不开发一门我们自��q��语言�Q�它拥有 Lisp,Prolog和Parlog的特性，但内�|�了�q�发和容错处理�?
1987
�W�一�ơ��用erlang�q�行实验�?
1988
ACS/Dunder�Q�项�?�W�一阶段�Q�外来用户��用erlang�q�行PABX(专用自动交换分机)功能的原型构建， Erlang走出了实验室�Q?/em>
1989

ACS/Dunder�Q�项�?�W�二阶段�Q�重新改造了完整的MD-110�pȝ��?/10�Q�结�?相比于��用PLEX的构建有>>10倍的效率提高�Q?

1990
Erlang正式以ISS'90标准发布�Q�这带来不少的新用户�Q�比如Bellcore�?
1991
Erlang发布了更快的版本实现�l�用��P��Erlang应用于电�?91�Q�项目？�Q�，更多功能比如�~�译器、图形接口等�?
1992
更多的新用户�Q�许多高速发展的��目。Erlang可以�q�行于VxWorks,PC,Macintosh�{�系�l�。有三个应用使用了ISS'92标准的Erlang�?
1993
分布式支持加�q�了Erlang,�q��得erlang可以�q�行一个自发系�l�在不同的硬件上。决定向外部发布Erlang的实玎ͼ�从爱立信分离出独立的部门开始维护和支持Erlang的实现和Erlang工具的开发工作�?

dennis 2007-06-14 09:28 发表评论

dennis — Wed, 13 Jun 2007 06:36:00 GMT
    读erlang.org上面的Erlang Course四天教程
1.数字�c�d��Q�需要注意两�?br>1�Q�B#Val表示以B�q�制存储的数字Val�Q�比�?br>
7> 2#101.
5
�?/span>�q�制存储�?01��是10�q�制�?�?br>2�Q?Char表示字符Char的ascii�~�码�Q�比�?A表示65

2.比较难以��译的概念——atom�Q�可以理解成帔R��Q�它可以包含��M��字符�Q�以��写字母开��_��如果不是以小写字母开头或者是字母之外的符��P��需要用单引号包括�v来，比如abc,'AB'

3.另一个概念——Tuple,有�h��译成元�l�，可以理解成定长数�l�，是Erlang的基��数据�l�构之一�Q?br>
8> {1,2,3,4,5}.
{1,2,3,4,5}
9> {a,b,c,1,2}.
{a,b,c,1,2}
10> size({1,2,3,a,b,c}).
6
内置函数size求长度，元组可以嵌套元组或者其他结构。下面所讲的列表也一栗��?br>
4.另外一个基��数据�l�构��是各个语言都有的list�Q�列表）�Q�在[]内以,隔开�Q�可以动态改变大��，
    [123, xyz]
    [123, def, abc]
    [{person, 'Joe', 'Armstrong'},
        {person, 'Robert', 'Virding'},
        {person, 'Mike', 'Williams'}
    ]
可以使用内置函数length求列表大��。以""包含的ascii字母代表一个列表，里面的元素就是这些字母的ascii��|��比如"abc"表示列表[97,98,99]�?br>
5.通过�q�两个数据结构可以组合成各种复杂�l�构�Q�与Lisp的cons、list演化出各�U�结构一��L��奇妙,Erlang也可以当作是操作列表的语�a��?br>
6.Erlang中变量有两个特点�Q?br>1�Q�变量必��M��大写字母或者下划线开��_��可以包含字母、下划线和@
2�Q�变量只能绑定一�ơ，也就是所谓的Single Assignment。或者以一般的说法��是只能赋��g��ơ，其实Erlang�q�没有赋��D��L��概念,=号也是用于验证匹配�?br>
7.模式匚w��——Pattern Matching�Q�Erlang的模式匹配非常强大，看了buaawhl的�?a >Erlang语法提要》的介绍�Q�模式匹配的功能不仅仅在评��中介�l�的数据�l�构的拆解，在程序的分派也扮演重要角�Ԍ��或者说Erlang的控制的��{是通过模式匚w��来实现的。具体功能参见链接，�l�出书中拆解列表的例子：

    [A,B|C] = [1,2,3,4,5,6,7]
        Succeeds - binds A = 1, B = 2,
        C = [3,4,5,6,7]

    [H|T] = [1,2,3,4]
        Succeeds - binds H = 1, T = [2,3,4]

    [H|T] = [abc]
        Succeeds - binds H = abc, T = []

    [H|T] = []
        Fails

下面会给出更多模式匹配的例子�Q�给��Z��个模块用来计��列表等

8.Erlang中函数的定义必须在一个模块内�Q�Module�Q�，�q�且模块和函数的名称都必��L��atom�Q�函数的参数可以是�Q何的Erlang�c�d��或者数据结构，函数要被调用需要从模块中导出，函数调用的�Ş式类��|��
moduleName:funcName(Arg1,Arg2,...).
写我们的�W�一个Erlang�E�序�Q��h见�h��q��Hello World�Q?br>
-module(helloWorld).
-export([run/1]).
run(Name)->
    io:format("Hello World ~w~n",[Name]).
存�ؓhelloWorld.erl�Q�在Erlang Shell中执行：

2> c(helloWorld).
{ok,helloWorld}
3> helloWorld:run(dennis).
Hello World dennis
ok
打印出来了，现在解释下程序构造，

-module(helloWorld).
�q�一行声明了模块helloWorld�Q�函数必��d��义在模块内，�q�且模块名称必须与源文�g名相同�?br>
-export([run/1]).
而这一行声明导出的函数�Q�run/1指的是有一个参数的run函数�Q�因为Erlang允许定义同名的有不同参数的多个函敎ͼ�通过指定/1来说明要导出的是哪个函数�?br>接下来就是函数定义了�Q?br>
run(Name)->
    io:format("Hello World ~w~n",[Name]).
大写开头的是变量Name�Q�调用io模块的format�Ҏ��输出�Q�~w可以理解成占位符�Q�将被实际Name取代�Q�~n��是换行了。注意，函数定义完了要以句号.�l�束。然后执行c(helloWorld).�~�译源代码，执行�Q?br>
helloWorld:run(dennis);

9.内置的常用函敎ͼ�

    date()
    time()
    length([1,2,3,4,5])
    size({a,b,c})
    atom_to_list(an_atom)
    list_to_tuple([1,2,3,4])
    integer_to_list(2234)
    tuple_to_list({})
    hd([1,2,3,4]) %输出1�Q�也��是列表的head�Q�类似Lisp的car
    tl([1,2,3,4]) %输出[2,3,4],也就是列表的tail,�c�M��List的cdr

10.常见Shell命��o�Q?br>1�Q?span style="font-weight: bold;">h(). 用来打印最�q�的20条历史命�?br>2�Q?span style="font-weight: bold;">b(). 查看所有绑定的变量
3) f(). 取消�Q�遗忘）所有绑定的变量�?br>4) f(Val). 取消指定的绑定变�?br>5) e(n).   执行�W�n条历史命�?br>6) e(-1). 执行上一条shell命��o

11.又一个不知道怎么��译的概念——Guard。翻译成�U�束�Q�呵��c��用于限制变量的�c�d��和范��_��比如�Q?br>
     number(X)    - X 是数�?br>    integer(X)    - X 是整�?br>    float(X)    - X 是��Q�Ҏ��
    atom(X)        - X 是一个atom
    tuple(X)    - X 是一个元�l?br>    list(X)        - X 是一个列�?br>
    length(X) == 3    - X 是一个长度�ؓ3的列�?br>    size(X) == 2    - X 是一个长度�ؓ2的元�l?br>
    X > Y + Z    - X >Y+Z
    X == Y        - X 与Y相等
    X =:= Y        - X 全等于Y
    (比如�Q?nbsp;1 == 1.0 成功
               1 =:= 1.0 ��p�|)
��Z��方便比较�Q�Erlang规定如下的比较顺序：

number < atom < reference < port < pid < tuple < list
其中pid��是process的id�?br>
12.忘了介绍apply函数�Q�这个函数对于熟悉javascript的�h来说很亲切，javascript实现mixin��得靠它�Q�它的调用方式如下：

apply(Mod, Func, Args),三个参数分别是模块、函��C��及参数列表，比如调用我们的第一个Erlang�E�序�Q?br>
apply(helloWorld,run,[dennis]).
13.if和case语句�Q�if语句的结构如下：
if
Guard1 ->
Sequence1 ;
Guard2 ->
Sequence2 ;
...
end
而case语句的结构如下：

case Expr of
Pattern1 [when Guard1] -> Seq1;
Pattern2 [when Guard2] -> Seq2;

PatternN [when GuardN] -> SeqN
end

if和case语句都有一个问题，��是当没有模式匹配或者Grard都是false的时候会��D��error�Q�这个问题case可以增加一个类似java中default的：

case Fn of

   _ ->
   true
end
通过_指代��L��的Expr�Q�返回true,而if可以�q�样�Q?br>
if

  true ->
   true
end
一��L��道理。case语句另一个需要注意的问题��是变量范围�Q�每个case分支中定义的变量都将默认导出case语句�Q�也��是在case语句�l�束后可以被引用�Q�因此一个规则就是每个case分支定义的变量应该一��_��不然��是非法的，�~�译器会�l�出警告�Q�比如：

f(X) ->
case g(X) of
true -> A = h(X), B = A + 7;
false -> B = 6
end,
h(A).

如果执行true分支�Q�变量A和变量B都被定义�Q�而如果执行的false分支�Q�只有变量B被定义，可在case语句执行后，h(A)调用了变量A�Q�这是不安全的，因�ؓ变量A完全可能没有被定义，�~�译器将�l�出警告
variable 'A' unsafe in 'case' (line 10)

14.�l�出一些稍微复杂的模型匚w��例子�Q�比如用于计��数字列表的和、��^均倹{��长度、查找某元素是否在列表中�Q�我们把�q�个模块定义为list:

-module(list).
-export([average/1,sum/1,len/1,double/1,member/2]).
average(X)->sum(X)/len(X).
sum([H|T]) when number(H)->H+sum(T);
sum([])->0.
len([_|T])->1+len(T);
len([])->0.
double([H|T]) -> [2*H|double(T)];
double([]) -> [].
member(H, [H|_]) -> true;
member(H, [_|T]) -> member(H, T);
member(_, []) -> false.


�l�细体会�Q�利用递归来实玎ͼ�比较有趣�Q�这其实与Lisp中利用尾递归来实现�P代是一��L��道理�Q�[H|T]的�Ş式类似Lisp中的car、cdr操作。_用于指代��L��的变量，当我们只��x��此处有变量，但�ƈ不关心变量的值的时候��用。用分号;来说明是同一个函数定义，只是不同的定义分支，通过模式匚w��来决定调用哪个函数定义分支�?br>另一个例子，计算各种囑�Ş的面�U�，也是评��中给出的例子�Q?br>

-module(mathStuff).
-export([factorial/1,area/1]).
factorial(0)->1;
factorial(N) when N>0->N*factorial(N-1).
%计算正方形面�U?/span>�Q�参数元�l�的�W�一个匹配square
area({square, Side}) ->
    Side * Side;
%计算圆的面积�Q�匹配circle
area({circle, Radius}) ->
   % almost :-)
   3 * Radius * Radius;
%计算三角形的面积�Q�利用�v伦公式，匚w��triangle
area({triangle, A, B, C}) ->
   S = (A + B + C)/2,
math:sqrt(S*(S-A)*(S-B)*(S-C));
%其他
area(Other) ->
   {invalid_object, Other}.

执行一下看看：

1> c(mathStuff).
{ok,mathStuff}
2> mathStuff:area({square,2}).
4
3> mathStuff:area({circle,2}).
12
4> mathStuff:area({triangle,2,3,4}).
2.90474
5> mathStuff:area({other,2,3,4}).
{invalid_object,{other,2,3,4}}

Erlang使用%开始单行注释�?br>

dennis 2007-06-13 14:36 发表评论

`-connect_all false`	上面已经解释�?
`-hidden`	启动一个hidden node
`-name Name`	启动一个系�l�成��点，使用long name.
`-setcookie Cookie`	�?code>Erlang:set_cookie(node(), Cookie).相同�Q�设�\|�magic cookie
`-sname Name`	启动一个Erlang�pȝ��作�ؓ节点�Q��用short name

亚洲人av高清无码,亚洲动漫精品无码av天堂,亚洲欧洲日产国码久在线观看

Ruby Fiber指南�Q�五�Q�： 实现Actor�Q�兼谈Erlang的process调度

Erlang���介的PPT�Q�达人勿入）

Rabbitmq的网�l�层���析

Erlang Web Shell(update)

Erlang之IO�~�程

���单的web server性能���试

Erlang ring benchmark

Erlang分布式在linux和windows上的注意事项

Erlang入门�Q�三�Q�——分布式�~�程

Erlang前世今生

1982 - 1985

1985 - 86

1987

1988

1989

1990

1991

1992

1993

Ruby Fiber指南�Q�五�Q�：实现Actor�Q�兼谈Erlang的process调度

Erlang��介的PPT�Q�达人勿入）

Rabbitmq的网�l�层��析

��单的web server性能��试