This document contains information about EventMachine and the reactor pattern in Ruby. It discusses how EventMachine implements the reactor pattern to allow non-blocking and asynchronous I/O in Ruby. It provides examples of how to use EventMachine to run code asynchronously using callbacks, timers, queues, and fibers to avoid "callback hell". The document also lists several other languages and frameworks that use the reactor pattern for asynchronous programming.

1. Don’t block the event loop!
EventMachine: Scalable non-blocking i/o in ruby

2. Jinpu Hu (胡金埔)
Blog: http://hujinpu.com/
Github: https://github.com/hujinpu
Twitter: https://twitter.com/#!/hujinpu
Sina weibo: http://weibo.com/hujinpu
Email: hujinpu@gmail.com

3. Blocking IO sucks

4. Evented IO rules

5. CXXXK problem

6. CXXXK problem
RPS（QPS/TPS）
TPR
Concurrency Level

7. Efficient Processing
Focus on maximizing machine utilization
Google tries for ~80% utilization

8. Different
non blocking i/o
asynchronous programming

9. • Blocking IO a UNIVERSAL problem
• All programming languages have trouble with it
• The Reactor pattern resolves it
• Most languages have the Reactor pattern!
JavaScript Node.js
Python Twisted
Ruby EventMachine
Java MINA
Lua LuaNode

10. Reactor Pattern
What’s reactor?
What’s design patterns?
So, what’s reactor pattern?

11. reactor
reactor is simply a single thread, endless loop
It reacts to incoming events

12. design patterns
http://en.wikipedia.org/wiki/Pattern

13. reactor pattern
resources (description/file handler)
synchronous event demultiplexer (select/epoll/kqueue)
dispatcher
request handler

14. What’s eventmachine?
Ruby implementation of the Reactor pattern
Single threaded by default
Allows us to interleave multiple IO ops and a single
CPU op simultaneously

15. Let’s play with EM
gem install eventmachine --pre

16. EM.run
takes a block to execute once the reactor has started
EM.run is blocking
the loop takes over the ruby process, so code after
EM.run will not run
all your code(relative to em) must in EM.run

17. EM.next_tick
queue a proc to be executed on the next iteration of
the reactor loop

18. EM.tick_loop
80k+/s
on my mac air

19. EM::Iterator
That’s cool for writing crawler

20. EM.defer
on first invocation, spawns up EM.threadpool_size
threads in a pool
all the threads read procs from a queue and execute
them in parallel to the reactor thread
optional second proc is invoked with the result of the
first proc, but back inside the reactor thread

21. EM::Timer

22. EM::Queue
async queue
if queue is empty, it is invoked when someone calls
#push

23. EM::Channel

24. EM.system

25. Network Servers and Clients
EM.start_server / EM.stop_server
EM.connect / EM.bind_connect
EM.open_datagram_socket

27. TCP is stream

28. And more
read eventmachine source code!

29. Callback Hell
var useFile = function(filename,callback){
posix.stat(filename).addCallback(function (stats) {
posix.open(filename, process.O_RDONLY, 0666).addCallback(function (fd) {
posix.read(fd, stats.size, 0).addCallback(function(contents){
callback(contents);
});
});
});
};

30. Fiber
What’s fiber?
How to use fiber?

31. what’s fiber
light weight cooperative concurrency
the scheduling must be done by the
programmer and not the VM
a small 4KB stack

32. use fiber
http://ruby-doc.org/core-1.9.3/Fiber.html

33. Solotion to callback hell
Fiber into EM = em-synchrony
thanks to Ilya Grigorik(CTO of PostRank)

35. The End