Este documento describe diferentes modelos de concurrencia como procesos, hilos, reactor, CSP, Erlang/OTP y promesas/futuros. Procesos y hilos permiten la ejecución simultánea de tareas compartiendo recursos. El modelo reactor usa un bucle de eventos para alternar entre tareas. CSP y Erlang/OTP usan comunicación por paso de mensajes entre procesos ligeros. Las promesas/futuros permiten la ejecución asíncrona de tareas en cadena.

1. Modelos de
concurrencia
Erick Camacho @ecamacho
CTO Nubleer

3. The Free Lunch Is Over. A Fundamental Turn Toward
Concurrency in Software
Herb Sutter (Marzo 2005)

4. "Applications will increasingly need to be concurrent if they
want to fully exploit continuing exponential CPU throughput
gains"
- Herb Sutter

6. ¿Qué es?
• Paralelismo: Ejecución simultánea de tareas.
• Concurrencia: Cuando dos o más tareas se
ejecutan de forma independiente en periodos de
tiempo traslapados.

7. ¿Qué es?
• http://concurrencia-go.appspot.com/
go_sgce.slide#25

8. 1. Procesos
• Tarea que utiliza el recurso de una computadora.
• Memoria, CPU, red, disco.
• Aislados
• Fork

9. 1. Procesos
• Context - switching
• Multitasking
• Se comunican por RPC
• Costosos: ulimit -u > 709

13. 2. Threads
• Componente de un proceso
• Múltiples threads por proceso
• Memoria compartida
• 2 mb en Linux

14. 2. Threads
• La programación es compleja: semáforos, waits,
etc.
• Context switching más rápido que los procesos
• Más ligeros que los procesos
• Técnica común: Pool de threads

15. 2. Threads
“Concurrency Options on the JVM” @jessitron

16. 2. Threads

17. 2. Threads

18. 3. Reactor
• Event-loop
• 1 sólo thread
• Loop de eventos: Reactor va turnando la tarea a
ejecutar
• Descrito por Douglas Schmidt en 2000

19. 3. Reactor

20. 3. Reactor
Node.js event loop

21. 3. Reactor

22. 3. Reactor

23. 3. Reactor
• Si una tarea se tarda mucho, afecta a las otras.
• Memoria compartida
• Fácil de entender

24. 4. CSP (GO)
• Presentación

25. 5. Erlang / OTP
Basado en el Actores:
1973: Carl Hewitt, Peter Bishop y Richard Steiger
• Procesos ligeros y aislados
• Share-nothing para evitar efectos colaterales
(Programación Funcional)
• Comunicación basada en paso de mensajes
• Location transparency

26. 5. Erlang / OTP
• Un SO para gestionar procesos ligeros
• ~1.8k de heap inicial
• Una máquina virtual (BEAM)
• Un lenguaje: Erlang
• Un framework para sistemas concurrentes y
tolerantes a fallas: OTP

27. 5. Erlang / OTP
• Procesos aislados (seguridad)
• Ligeros (puedes tener millones)
• Tolerante a fallos
• Monitores y alarmas

28. 5. Erlang / OTP

29. 5. Erlang / OTP
Supervisores
Workers
OTP App

30. 5. Erlang - Elixir
• Creado por José Valim
• 1.0 liberada en septiembre
• Sintaxis más clara y familiar
• Macros!
• Protocolos
• Herramientas para automatizar builds y despliegues

31. 5. Erlang - Elixir
parent = self()
# Spawns an Elixir process (not an operating system one!)
spawn_link(fn ->
send parent, {:msg, "hello world"}
end)
# Block until the message is received
receive do
{:msg, contents} -> IO.puts contents
end

32. 5. Erlang(o Elixir)/OTP

34. 6. Promises / Futures
• Promises: 1976 Daniel P. Friedman y David Wise
• Futures: 1977 Henry Baker y Carl Hewitt

35. 6. Ejemplo: q
step1(function (value1) {
step2(value1, function(value2) {
step3(value2, function(value3) {
step4(value3, function(value4) {
// Do something with value4
});
});
});
});

36. 6. Ejemplo: q
Q.fcall(promisedStep1)
.then(promisedStep2)
.then(promisedStep3)
.then(promisedStep4)
.then(function (value4) {
// Do something with value4
})
.catch(function (error) {
// Handle any error from all above steps
})
.done();

37. 6. Promises / Futures
• Implementados en la mayoría de lenguajes: Java,
javascript, .NET, Scala, Clojure, Elixir, Ruby, Obj-c,
Swift.
• Dependen del modelo de concurrencia de la
plataforma.

38. 6. Scala
scala> val something = Future { 10 + 6 }
something: scala.concurrent.Future[Int] =
scala.concurrent.impl.Promise$DefaultPromise@5535cbe
scala> Await.result(something, 0 nanos)
res1: Int = 16

39. 6. Elixir
something = Task.async fn ->
...(1)> 10 + 6
...(1)> end
%Task{pid: #PID<0.44.0>, ref:
#Reference<0.0.0.55>}
iex(2)> Task.await(something)
16

40. Scala / Elixir
• Scala: modelo polling. Se crea un thread y
periodicamente se le pregunta si ya terminó
• Elixir: modelo push. Se crea un proceso
independiente que nos notifica cuando termina.
• Fuente: Peter Hamilton http://
undiscoveredfeatures.com/elixir-tasks-vs-scala-
futures/

41. Gracias
@ecamacho