Research on EventMachine

为什么我们需要EventMachine？

我们通常说的Ruby解释器里的Ruby线程是Green Thread：即程序里面的线程不会真正映射到操作系统的线程，而是由语言运行平台自身来调度，并且这种线程的调度不是并行的。

关于Ruby的并发问题这里有一个权威的解释：http://www.igvita.com/2008/11/13/concurrency-is-a-myth-in-ruby

这篇文章提到造成这种情况的原因主要是由于Ruby解释器和VM中GIL（Global Interpreter Lock，如下图所示）的存在，使得Ruby始终无法真正的享受多核带来的好处，尽管在Ruby1.9的解释器已经能够使用多个系统级别的线程，但是GIL为了保证我们代码的线程安全，只允许同一时刻运行一个单一的线程。当然，事情并不是绝对的，下图最右的JRuby则把线程调度的工作交给了JVM从而实现任务的并发执行。

所以，基于Ruby的复杂应用大多采用了这样的一种策略：使用推迟（defer）并发（parallelize）的方法来处理程序中的网络I/O部分，而不是引入线程到应用程序中。

EventMachine 就是一个基于Reactor设计模式的、用于网络编程和并发编程的框架。Reactor模式描述了一种服务处理器——它接受事件并将其分发给已注册的事件处理。这种模式的好处就是清晰的分离了时间分发和处理事件的应用程序逻辑，而不需引入多线程来把代码复杂化。

EventMachine 本身提供了操作方便的网络套接字和隐藏底层操作的编程接口，这使得EM在CloudFoundry中被广泛的使用着。接下来，我们将对其机制进行一个简单的说明。

Reactor Pattern

“The reactor design pattern is an event handling pattern for handling service requests delivered concurrently to a service handler by one or more inputs. The service handler then demultiplexes the incoming requests and dispatches them synchronously to the associated request handlers.”——wiki

p.s. 这样的工作方式有些类似于Observer Pattern，但后者只监听一个固定主题的消息。

上述定义可以用下面的图示来描述，其中灰色的部分就是Reactor：

Demultiplexer：是单进程阻塞式的主事件循环（event loop）。只要它没有被阻塞，它就能够将请求交给event dispatcher。

Dispatcher：负责event handler的注册和取消注册，并将来自Demultiplexer的请求交给关联的event handler。

Event handler：是最终处理请求的部分。

1、一个最简单基于EM的HttpServer的例子

1. require 'rubygems'  
2. require 'eventmachine'  
3.   
4. class Echo < EM::Connection    
5.   def receive_data(data)    
6.     send_data(data)    
7.   end    
8. end  
9.    
10. EM.run do    
11.   EM.start_server("0.0.0.0", 10000, Echo)    
12. end   

在另一个窗口，输入hello，服务器返回hello：

1. telnet localhost 10000  
2.   
3. Trying 127.0.0.1...  
4. Connected to localhost.  
5. Escape character is '^]'.  
6. hello  
7. hello  

仔细看一下上面的程式：EM帮我们启动了一个server，监听端口10000，而Echo实例（继承了Connection，用来处理连接）则重写了receive_data方法来实现服务逻辑。

而EM.run实际上就是启动了Reactor，它会一直运行下去直到stop被调用之后EM#run之后的代码才会被执行到。Echo类的实例实际上是与一个File Descriptor注册在了一起（Linux把一切设备都视作文件，包括socket），一旦该fd上有事件发生，Echo的实例就会被调用来处理相应事件。

在CloudFoundry中，组件的启动大多是从EM.run开始的，并且出于在多路复用I/O操作时提高效率和资源利用率的考虑，CF组件往往会在EM.run之前先调用EM.epoll （EM默认使用的select调用），比如：

1. EM.epoll  
2.   
3. EM.run {  
4.   ...  
5.   
6.   NATS.start(:uri => @nats_uri) do  
7.   
8.     # do something  
9.   
10.   end  
11.   
12.   ...  
13.  }  

2、EM定时器（Timer）

EM中有两种定时器，add_timer添加的是一次性定时器，add_periodic_timer添加的是周期性定时器。

1. require 'eventmachine'  
2. EM.run do  
3.   p = EM::PeriodicTimer.new(1) do  
4.     puts "Tick ..."  
5.   end  
6.   
7.   EM::Timer.new(5) do  
8.     puts "BOOM"  
9.     p.cancel  
10.   end  
11.   
12.   EM::Timer.new(8) do  
13.     puts "The googles, they do nothing"  
14.     EM.stop  
15.   end  
16. end  
17.   
18. #输出：  
19. Tick...  
20. Tick...  
21. Tick...  
22. Tick...  
23. BOOM  
24. The googles, they do nothing  

细节：我们在第一个EM::PeriodicTimer代码块中，传入了另外一个代码块：puts “Tick”。这里实际上告诉了 EM 每隔1秒触发一个事件，然后才调用puts代码块，这里的puts代码块就是回调。

3、推迟和并发处理

EM#defer和EM#next_tick发挥作用的地方分别是：1、长任务应该放到后台运行；2、一旦这些任务被转移到后台，Reactor能够立刻回来工作。。

EM#defer方法

负责把一个代码块（block）调度到EM的线程池中执行（这里固定提供了20个线程），而defer的Callback参数指定的方法将会在主线程（即Reactor线程）中执行，并接收 后台线程的返回值作为Callback块的参数。

1. require 'eventmachine'  
2. require 'thread'  
3.   
4. EM.run do  
5.   EM.add_timer(2) do  
6.     puts "Main #{Thread.current}"  
7.     EM.stop_event_loop  
8.   end  
9.   EM.defer do  
10.     puts "Defer #{Thread.current}"  
11.   end  
12. end  
13.   
14.   
15. Defer #<Thread:0x7fa871e33e08>   
16. #两秒后  
17. Main #<Thread:0x7fa87449b370>   

执行示意图如下：

EM#defer+Callback的用法：

1. require 'rubygems'  
2. require 'eventmachine'  
3.   
4. EM.run do  
5.   op = proc do  
6.     2+2  
7.   end  
8.   callback = proc do |count|  
9.     puts "2 + 2 == #{count}"  
10.     EM.stop  
11.   end  
12.   EM.defer(op, callback)  
13. end  
14.   
15. # the return value of op is passed to callback  
16. #2 + 2 == 4  

EM#next_tick方法

负责将一个代码块调度到Reactor的下一次迭代中执行，执行任务的是Reactor主线程。所以，next_tick部分的代码不会立刻执行到，具体的调度是由EM完成的。

1. require 'eventmachine'    
2.   
3. EM.run do    
4.   EM.add_periodic_timer(1) do    
5.     puts "Hai"    
6.   end   
7.    
8.   EM.add_timer(5) do    
9.     EM.next_tick do    
10.       EM.stop_event_loop    
11.     end    
12.   end    
13. end   

这里Reactor执行的过程用是同步的，所以太长的Reactor任务会长时间阻塞Reactor进程。EventMachine中有一个最基本原则我们必须记住：Never block the Reactor!

正是由于上述原因，next_tick的一个很常见的用法是递归的调用方式，将一个长的任务分配到Reactor的不同迭代周期去执行。

正常的循环代码：

1.  n = 0  
2.   while n < 1000    
3.     do_something  
4.     n += 1  
5.   end  

使用next_tick来处理: 

1. require 'rubygems'  
2. require 'eventmachine'  
3.   
4. EM.run do  
5.   n = 0    
6.   do_work = proc{    
7.     if n < 1000    
8.       do_something  
9.       n += 1   
10.       EM.next_tick(do_work)  
11.     else  
12.       EM.stop  
13.     end  
14.   }  
15.     
16.   EM.next_tick(do_work)    
17. end  

next_tick中的block执行如红色的Task 1所示：

如上图所示那样，next_tick使单进程的Reactor给其他任务运行的机会——我们不想阻塞住Reactor，但我们也不愿引入Ruby线程，所以才有了这种方法。

next_tick在CloudFoundry中应用非常广泛，比如下面Router启动的一部分代码：

1.   # Setup a start sweeper to make sure we have a consistent view of the world.  
2.   EM.next_tick do  
3.     # Announce our existence  
4.     NATS.publish('router.start', @hello_message)  
5.   
6.     # Don't let the messages pile up if we are in a reconnecting state  
7.     EM.add_periodic_timer(START_SWEEPER) do  
8.       unless NATS.client.reconnecting?  
9.         NATS.publish('router.start', @hello_message)  
10.       end  
11.     end  
12.   end  

与next_tick同样作用的方法还有EM.schedule，后者会不停地判断当前线程是不是Reactor线程。

next_tick还有个用处：当你通过defer方法把一个代码端调度到线程池中执行，然后又需要在主线程中使用EM::HttpClient来发一个出站连接，这时你就可以在前面的代码段里使用next_tick创建这个连接。

4、EM提供的轻量级的并发机制

EvenMachine内置了两钟轻量级的并发处理机制：Deferrables和SpawnedProcesses。

EM::Deferrable

如果在一个类中include了EM::Deferrable，就可以把Callback和Errback关联到这个类的实例。

一旦执行条件被触发，Callback和Errback会按照与实例关联的顺序执行起来。

对应实例的#set_deferred_status方法就用来负责触发机制：

当该方法的参数是:succeeded，则触发callbacks；而如果参数是:failed，则触发errbacks。触发之后，这些回调将会在主线程立即得到执行。当然你还可以在回调中(callbacks和errbacks)再次调用#set_deferred_status，改变状态。

1. require 'eventmachine'  
2.   
3. class MyDeferrable  
4.   include EM::Deferrable  
5.   def go(str)  
6.     puts "Go #{str} go"  
7.   end  
8. end  
9.   
10. EM.run do  
11.   df = MyDeferrable.new  
12.   
13.   df.callback do |x|  
14.     df.go(x)  
15.     EM.stop  
16.   end  
17.   
18.   EM.add_timer(1) do  
19.     df.set_deferred_status :succeeded, "SpeedRacer"  
20.   end  
21. end  
22.   
23.   
24. #1s 之后：  
25. Go SpeedRacer go  

EM::SpawnedProcess

这个方法的设计思想是：允许我们创建一个进程，把一个代码段绑定到这个进程上。然后我们就可以在某个时刻，让spawned实例被#notify方法触发，从而执行关联好的代码段。

它与Deferrable的不同之处就在于，这个block并不会立刻被执行到。

1. require 'rubygems'  
2. require 'eventmachine'  
3.   
4. EM.run do  
5.   s = EM.spawn do |val|  
6.     puts "Received #{val}"  
7.   end  
8.   
9.   EM.add_timer(1) do  
10.     s.notify "hello"  
11.   end  
12.   
13.   EM.add_periodic_timer(1) do  
14.     puts "Periodic"  
15.   end  
16.   
17.   EM.add_timer(3) do  
18.     EM.stop  
19.   end  
20. end  
21.   
22. #1s之后同时输出前两个，第二秒后输出Periodic  
23. Periodic  
24. Received hello  
25. Periodic  

注意这两种机制的使用方式是不一样的：一个是作为内部类include进去进而使用其定义的callback来执行的；而另一个是直接使用spawn实例通过notify来触发代码块来执行的。

5、使用EM简化网络编程

网络编程的简单化是ＥＭ的一大特色。拿前面的Echo举例子，我们通过十分简洁的代码就可以实现一个HttpServer的功能。

我们其实还有更简洁的方式来完成这个工作，比如使用module：

1. require 'eventmachine'  
2.   
3. module Echo  
4.   def receive_data(data)  
5.     send_data(data)  
6.   end  
7. end  
8.   
9. EM.run do  
10.   EM.start_server("0.0.0.0", 10000, Echo)  
11. end  

以及直接使用block：

1. require 'eventmachine'  
2.   
3. EM.run do  
4.   EM.start_server("0.0.0.0", 10000) do |srv|  
5.     def srv.receive_data(data)  
6.        send_data(data)  
7.     end  
8.   end  
9. end  

事实上，每次你新建一个连接，一个新的包含了你代码的匿名类就会被创建。理论上，不同的连接不能互相交换信息，这一点很重要。不过EM实际上在设计时以及解决这个问题：

1. require 'rubygems'  
2. require 'eventmachine'  
3.   
4. class Pass < EM::Connection  
5.   attr_accessor :a, :b  
6.   def receive_data(data)  
7.     send_data "#{@a} #{data.chomp} #{b}"  
8.   end  
9. end  
10.   
11. EM.run do  
12.   EM.start_server("127.0.0.1", 10000, Pass) do |conn|  
13.     conn.a = "Goodbye"  
14.     conn.b = "world"  
15.   end  
16. end  

通过给start_server添加一个块，EM会把把Pass的实例传进去（这个操作发生时实例已经被初始化但是客户端数据还没收到）。这样我们可以用这种方法为每个实例set值。


下面我们使用EventMachine建立一个客户端，这是非常简单的事情：

1. require 'rubygems'  
2. require 'eventmachine'  
3.   
4. class Connector < EM::Connection  
5.   def post_init  
6.     puts "Getting /"  
7.     send_data "GET / HTTP/1.1\r\nHost: MagicBob\r\n\r\n"  
8.   end  
9.    
10.   def receive_data(data)  
11.     puts "Received #{data}"  
12.     puts "Received #{data.length} bytes"  
13.   end  
14. end  
15.   
16. EM.run do  
17.   EM.connect('127.0.0.1', 10000, Connector)  
18. end  

除了使用EM#connect之外，客户端同服务器端的代码是一样的。其实EM::Connection类中还有很多有用的方法等着你实现：

post_init   当实例创建好，连接还没有完全建立的时候调用。一般用来做初始化
connection_completed   连接完全建立好的时候调用
receive_data(data)   当收到另一端的数据时调用。数据是成块接收的
unbind   当客户端断开连接的时候调用

此外，还有#close_connection#close_connection_after_writing这两个方法供用户断开连接。

下面给出一个更完整的例子，设置最大连接次数：

1. require 'rubygems'  
2. require 'eventmachine'  
3.   
4.  module LineCounter  
5.    MaxLinesPerConnection = 10  
6.   
7.    def post_init  
8.      puts "Received a new connection"  
9.      @data_received = ""  
10.      @line_count = 0  
11.    end  
12.   
13.    def receive_data data  
14.      @data_received << data  
15.      while @data_received.slice!( /^[^\n]*[\n]/m )  
16.        @line_count += 1  
17.        send_data "received #{@line_count} lines so far\r\n"  
18.        @line_count == MaxLinesPerConnection and close_connection_after_writing  
19.      end  
20.    end  
21.  end  
22.   
23.  EventMachine::run {  
24.    host,port = "192.168.0.100", 8090  
25.    EventMachine::start_server host, port, LineCounter  
26.    puts "Now accepting connections on address #{host}, port #{port}..."  
27.    EventMachine::add_periodic_timer( 10 ) { $stderr.write "*" }  
28.  }  

6、EventMachine的并发处理能力测试

“基于ruby事件驱动的服务器非常适合轻量级的请求，但对于长时间的请求，则性能不佳”。我们下面的例子将告诉你这样的认识其实是不对的。（需要用到eventmachine_httpserver来处理http请求和发送响应）

1. require 'rubygems'  
2. require 'eventmachine'  
3. require 'evma_httpserver'  
4.   
5. class Handler  < EventMachine::Connection  
6.   include EventMachine::HttpServer  
7.   
8.   def process_http_request  
9.     resp = EventMachine::DelegatedHttpResponse.new( self )  
10.   
11.     sleep 2 # Simulate a 2s long running request  
12.   
13.     resp.status = 200  
14.     resp.content = "Hello World!"  
15.     resp.send_response  
16.   end  
17. end  
18.   
19. EventMachine::run {  
20.   EventMachine::start_server("0.0.0.0", 8080, Handler)  
21.   puts "Listening..."  
22. }  
23.   
24. # Benchmarking results:  
25. #  
26. # > ab -c 5 -n 10 "http://127.0.0.1:8080/"  
27. # > Concurrency Level:      5  
28. # > Time taken for tests:   20.6246 seconds  
29. # > Complete requests:      10  

这是一个最简单的HTTPserver，我们通过ab(ApacheBench)测试：并发数设置为5(-c 5)，请求数设置为10(-n10)。耗时略大于20秒。正如上面所说

，Reactor同步地处理每个请求，相当于并发数设置为1。因此，10个请求，每个请求耗时2秒

1. require 'rubygems'  
2. require 'eventmachine'  
3. require 'evma_httpserver'  
4.   
5. class Handler  < EventMachine::Connection  
6.   include EventMachine::HttpServer  
7.   
8.   def process_http_request  
9.     resp = EventMachine::DelegatedHttpResponse.new( self )  
10.   
11.     # Block which fulfills the request  
12.     operation = proc do  
13.       sleep 2 # simulate a 2s long running request  
14.   
15.       resp.status = 200  
16.       resp.content = "Hello World!"  
17.     end  
18.   
19.     # Callback block to execute once the request is fulfilled  
20.     callback = proc do |res|  
21.         resp.send_response  
22.     end  
23.   
24.     # Let the thread pool (20 Ruby threads) handle request  
25.     EM.defer(operation, callback)  
26.   end  
27. end  
28.   
29. EventMachine::run {  
30.   EventMachine::start_server("0.0.0.0", 8081, Handler)  
31.   puts "Listening..."  
32. }  

好了，现在我们使用EM的线程池子来“并发”处理请求。结果还是10个请求，并发数设置为5。总共耗时仅仅4秒有余。就是这样，我们的这个server并

发地处理了10个请求。我们还可以通过这个方法来验证下线程池中的线程数量。

前面讲过的Deferable机制其实是以一种没有线程开销的情况下实现并发处理的方法。这种机制的一个典型场景就是，你在一个server中需要去请求另外一个server。

1. require 'rubygems'  
2. require 'eventmachine'  
3. require 'evma_httpserver'  
4.   
5. class Handler  < EventMachine::Connection  
6.   include EventMachine::HttpServer  
7.   
8.   def process_http_request  
9.     resp = EventMachine::DelegatedHttpResponse.new( self )  
10.   
11.     # query our threaded server (max concurrency: 20). this part is deferable  
12.     http = EM::Protocols::HttpClient.request(  
13.               :host=>"localhost",  
14.               :port=>8081,  
15.               :request=>"/"  
16.            )  
17.   
18.     # once download is complete, send it to client  
19.     http.callback do |r|  
20.         resp.status = 200  
21.         resp.content = r[:content]  
22.         resp.send_response  
23.     end  
24.   
25.   end  
26. end  
27.   
28. EventMachine::run {  
29.   EventMachine::start_server("0.0.0.0", 8082, Handler)  
30.   puts "Listening..."  
31. }  
32.   
33. # Benchmarking results:  
34. #  
35. # > ab -c 20 -n 40 "http://127.0.0.1:8082/"  
36. # > Concurrency Level:      20  
37. # > Time taken for tests:   4.41321 seconds  
38. # > Complete requests:      40  

从测试结果我们可以看到，这个server在4s多的时间里处理了40个请求（因为并发量是20，前面监听8081的服务器sleep是2s）。这就是EM的魅力：

当你的工作推迟或者阻塞在socket上，Reactor循环将继续处理其他的请求。当Deferred的工作完成之后，产生一个成功的信息并由reactor返回响应。

参考资料：

EventMachine Introduction：http://everburning.com/news/eventmachine-introductions/

EM官方tutorials：https://github.com/eventmachine/eventmachine/wiki/Tutorials

以及这篇著名的博客：http://www.igvita.com/2008/05/27/ruby-eventmachine-the-speed-demon/