Actors and Threads

Oct 1, 2011Download as KEY, PDF28 likes16,012 views

This document discusses concurrency and parallelism in Ruby. It defines concurrency as performing two operations in tandem, while parallelism refers to performing two operations literally at the same time using multiple cores. The document examines traditional approaches to concurrency like threads and locks in Ruby and their limitations. It advocates for adopting models from other languages like actors and software transactional memory that can provide safer concurrency through message passing and transactions rather than shared mutable state and locks. The document reviews several Ruby libraries that implement actors and proposes areas for further improvement in Ruby's core support for concurrent programming.

Actors and Threads
Safer Concurrency for Ruby

Mike Perham
@mperham

Who Am I?

• Numerous gems (dalli, memcache-client,
rack-ﬁber_pool, connection_pool, etc)
• Scalability/Performance guy
• Fibers and EventMachine
• Technical Lead at Carbon Five

Ruby History

• Fun!
• Implementation
• Performance
• Scalability

What This Isn’t

• Threads vs Events vs Processes
• Threads won’t make you love Java

Deﬁnitions
• Concurrency - performing two operations
in tandem (e.g. two web requests)
• Parallelism - performing two operations
literally at the same time (requires two
cores)
Concurrent

Parallel

The problem is always
communication

(true in the real world too!)

Communication

• Two fundamental mechanisms
• Share
• Copy

IPC

• Pipes
• Sockets
• Shared Memory
• Files
• POSIX 1988

Threads

• Much more efﬁcient than processes
• Communication mechanism?
• Variables!
• POSIX 1995

End Goals

• Runtime Efﬁciency isn’t the only goal!
• Remember Fun?
• Ease of Development is huge

Locks

• Hard to get right
• Non-deterministic
• Don’t scale

Lock Benchmark
# Results: Ruby 1.9.2, GIL means no parallel threading
# user system total real
# single locked 4.310000 0.010000 4.320000 ( 4.311850)
# threaded locked 4.230000 0.080000 4.310000 ( 4.307405)
#
# Results: JRuby 1.6.3, parallel threads mean massive lock contention
# user system total real
# single locked 4.080000 0.000000 4.080000 ( 4.080000)
# threaded locked 17.109000 0.000000 17.109000 ( 17.109000)

Context Switching!

What can we do?

• Look to other languages
• Go
• Scala
• Erlang

Goroutines
• Asynchronous function
• You cannot get a handle to it
• Send messages via a channel

Goroutines

• Really like this model
• Maps well to a distributed model
• Backed by a pool of threads

Actors

• unit of execution
• has a mailbox
• You just send it a message, e.g.
• actor << { :amount => 11.99 }

Actors

• Thread- or Fiber-backed
• No application-level locks

Actor.rb

• MRI/JRuby - no actors
• Rubinius comes with actor.rb

Actor.rb

• Not idiomatic
• Hard to understand, use correctly

Celluloid

• Tony Arcieri (Revactor, Reia)
• https://github.com/tarcieri/celluloid
• OO Actors
• Asynchronous method invocation
• Mix of Threads and Fibers

Celluloid Thoughts

• Nice, idiomatic Ruby design
• One object == one thread
• Needs actor pooling

girl_friday
• yours truly
• http://github.com/mperham/girl_friday
• Background processing pools
• Parallel batch operations
• More functional than OO
• Thread-based

STM

• Software Transactional Memory
• All mutation via transactions
• Provide ACI (not ACID) guarantees
• See Clojure (and Cloby!)

Atomic Instructions

• Since Pentium (1993)
• XCHG - swap registers or register/
memory
• CPMXCHG - Compare And Set (‘CAS’)

Atomic Benchmark
# Results: JRuby 1.6.3
# user system total real
# single atomic 2.041000 0.000000 2.041000 ( 2.041000)
# threaded atomic 0.978000 0.000000 0.978000 ( 0.979000)

2 cores = 2x speedup!

Atomic Structures

• java.util.concurrent
• ConcurrentHashMap
• ConcurrentLinkedQueue

Concurrency

It’s always hard!

Modern languages should support
tools and APIs that scale well AND
are developer-friendly.

To Do

• Need standard Actor API
• Concurrent data structures
• STM impl for Ruby (via JRuby?)
• Multiverse

Further Reading

• Kilim - Actors for Java
• Disruptor - concurrency without locks
• Actors in Scala
• Concurrency in Erlang

Thank You!
Questions?
@mperham
http://mikeperham.com
http://blog.carbonﬁve.com

PS We’re hiring!

The document discusses various concurrency models including shared state concurrency, message passing concurrency using actors, and software transactional memory. Shared state concurrency uses locking to synchronize access to shared resources but is prone to issues like race conditions and deadlocks. Message passing concurrency avoids these issues by isolating actors and having them communicate asynchronously through message passing without shared state. The actor model is implemented in several JVM languages including Scala, Groovy, and Java libraries. Software transactional memory provides an alternative to locking by allowing transactions to access shared memory in an isolated and atomic manner.

Actor Patterns and NATS - Boulder MeetupApcera

Actor model : A Different Concurrency ApproachEmre Akış

A gentle introduction into AKKA and the actor modelMykhailo Kotsur

This document introduces the actor model and Akka framework. It discusses that concurrency is the next revolution in software and the actor model provides a unified approach for concurrency and parallelism. It then demonstrates how to model ticket booking as actors that communicate asynchronously through message passing. Finally, it discusses additional Akka capabilities like persistence, clustering, and fault tolerance.

Model with actors and implement with AkkaNgoc Dao

This document provides an overview of actor modeling and how to implement actors using the Akka library. It begins with explaining the actor model and benefits of actors over threads. It then discusses how to create actors with Akka, demonstrating with a multiplayer chess game. The schedule outlines explaining the actor model for 1/4 of the time and how to create Akka actors for 3/4 of the time using the chess game demo. Useful links are provided for Akka documentation and chess/game related projects.

Introduction to Actor Model and AkkaYung-Lin Ho

Actor-based concurrency and Akka FundamentalsNgoc Dao

This document discusses actor-based concurrency and the Akka framework. It explains that actors are lightweight processes that communicate asynchronously by message passing rather than by sharing memory. This allows for high levels of concurrency. The document provides an example demonstrating how to define actor messages and behaviors in Akka to implement a simple counter actor. It also discusses some antipatterns to avoid, such as directly modifying actor state from outside the actor.

Hybrid concurrency patternsKyle Drake

Ruby developers need to stop using EventMachine. It's the wrong direction. Lost in the "Threads vs Event Driven vs Process Spawning" debate is that you can combine them! Learn how Celluloid is improving thread programming by abstracting them using a higher level framework called Celluloid, how you can use Celluloid::IO to throw a reactor pattern into a thread. Using this approach, you can take advantage of threading and use all CPU power on a machine with JRuby or Rubinius. I also discuss the future of distributed objects and computing, and where I think things are going.

How to start using ScalaNgoc Dao

Introducing AkkaJonas Bonér

The document introduces Akka, an open-source toolkit for building distributed, concurrent applications on the JVM. It provides a programming model called the actor model that makes it easier to build scalable and fault-tolerant systems. Actors process messages asynchronously and avoid shared state, providing a simpler approach to concurrency than traditional threads and locks. Akka allows actors to be distributed across a network, enabling applications to scale out elastically.

Introduction to Actor Model and AkkaYung-Lin Ho

The document discusses the actor model and Akka framework for building concurrent and distributed applications. It introduces some challenges of multi-threaded programming like non-determinism and shared mutable state. The actor model addresses these issues by representing entities as isolated actors that communicate asynchronously via message passing without shared state. Akka is an implementation of the actor model on the JVM that makes building fault-tolerant distributed systems easier. Key aspects covered include defining actors, routing messages, fault tolerance, and building remote actors for distribution. A Twitter-like messaging service is presented as a case study of how to structure such an application using Akka actors.

Akka FundamentalsMichael Kendra

This document provides an overview of Akka fundamentals including: - The actor model which uses message passing between encapsulated state and behavior units to achieve concurrency - The Akka actor API for building fault tolerant distributed applications in Scala and Java - Fault tolerance techniques in Akka like supervision which allows actors to monitor and respond to failures of child actors - Routing which provides abstractions for distributing messages to multiple receiver actors

Akka frameworkmitesh_sharma

Akka.net versus microsoft orleansBill Tulloch

CSP: Huh? And ComponentsDaniel Fagnan

This document discusses Communicating Sequential Processes (CSP) and building modular applications with components. It defines concurrency vs parallelism, explaining that concurrency is the model and parallelism is the act. Channels are presented as a powerful primitive for communication between concurrent tasks, allowing values to be put on or taken from the channel. Examples are given of CSP in Clojure and JavaScript. Components are described as a way to build modular applications with common client-server code sharing via a Unix style of small, concentrated modules. Globals are discouraged in favor of the module pattern.

Ruby is dying. What languages are cool now?Michał Konarski

- Ruby is no longer considered a "cool" language according to the author, who examines several languages that are currently popular including Swift, Rust, Go, Elixir, Julia, and Dart. - Swift was created by Apple to replace Objective-C and adds modern features while removing the complexity of C. Rust was created to be safe, concurrent, and practical while combining high and low level capabilities. Go was created at Google to be understandable, productive, and scale well for networking and multiprocessing. Elixir builds on Erlang's concurrency model and adds a Ruby-like syntax. Julia targets scientific computing by combining speed and interactivity. Dart was created by Google to replace JavaScript but never gained

Web development basics (Part-6)Rajat Pratap Singh

Online game server on Akka.NET (NDC2016)Esun Kim

Fast, concurrent ruby web applications with EventMachine and EM::SynchronyKyle Drake

This document summarizes Kyle Drake's presentation on using EventMachine (EM) and EM::Synchrony to build fast, concurrent Ruby web applications without blocking I/O or callback hell. Key points include: - EM implements the reactor pattern to handle blocking I/O without threads by using callbacks and kernel threads. - EM::Synchrony avoids callback nesting by wrapping callbacks in fibers, allowing synchronous-looking code. - Sinatra can be made concurrent by running each request in its own EM::Synchrony fiber with little code change. - Ruby has strong options for building high-performance concurrent apps while maintaining productivity advantages over Node.js.

Combining the strength of erlang and RubyMartin Rehfeld

Actors Set the Stage for Project Orleanscjmyers

Dim the lights and queue the music. The stage has been set, and the virtual actors are soon to arrive. Come join an engaging discussion on Project Orleans and how it will create for us a world that transcends traditional three-tier architecture and truly achieves solutions with a high degree of performance, reliability, and scalability. In this discussion, Chris will provide an overview of actor model theory and discuss how Orleans leverages virtual actors in order to provide a high throughput, low latency, and high availability solution architecture. You will also learn how this tried and tested framework has been successfully leveraged in Azure in order to provide the extremely scalable and performant platform that has brought you some of your favorite online Xbox games and Microsoft products.

About Clackfukamachi

Akka ActorsDylan Forciea

Actors provide a solution to issues with traditional concurrent programming like deadlocks and livelocks by treating all work as message passing between isolated entities called actors. Actors communicate asynchronously by message passing and avoid shared state, which simplifies concurrency. Akka is a toolkit for building applications and systems using the actor model that provides features like routing, supervision, and remote deployment of actors across networks.

Rethinking the debuggerIulian Dragos

New abstractions for concurrency make writing programs easier by moving away from threads and locks, but debugging such programs becomes harder. The call-stack, an essential tool in understanding why and how control flow reached a certain point in the program, loses meaning when inspected in traditional debuggers. Futures, actors or iteratees make code easier to write and reason about, and in this talk I'll show a simple solution to make them easier to debug. The tool I present integrates well with the Eclipse plugin for Scala, and shows how a "reactive debugger" might look like.

Functional Programming in ClojureTroy Miles

Paul Graham, the founder of startup incubator YCombinator, put it best when he described LISP as his old company's secret weapon. Think about, if you use all of the same tools as everyone else, how do you expect to achieve better results? Clojure is a LISP language created in 2009 by Rich Hickey. Built initially on the Java Virtual Machine (JVM) it has since been ported to run on Microsoft and JavaScript. (That's right the browser). Clojure gives you all of the power and stability of the JVM without the clunkiness of Java. Most developers have never worked with a functional language before and many who have found the use of parenthesis instead of braces intimidating. Don't worry. Once it is broken down to you, I think you will see the beauty of it. In this fast and fun session, we will build an app using Clojure. We will enhance it, test it and explore why functional is a better programming model than OOPs. We will even explore why such programs are better at multitasking than object oriented ones.

Erlang factory SF 2011 "Erlang and the big switch in social games"Paolo Negri

Elixir PhoenixTanuj Soni

Introduction to the Actor ModelBoldRadius Solutions

Akka Actor presentationGene Chang

Introduction to AkkaJohan Andrén

This document provides an introduction to Akka actors. It discusses how actors provide a model for building concurrent and distributed applications by avoiding shared mutable state and instead using message passing. Actors communicate asynchronously by message passing and handle errors through a supervision hierarchy. The document outlines several features of the actor model including load balancing, parallelization, and error handling.

More Related Content

What's hot (20)

How to start using ScalaNgoc Dao

Introducing AkkaJonas Bonér

Introduction to Actor Model and AkkaYung-Lin Ho

Akka FundamentalsMichael Kendra

Akka frameworkmitesh_sharma

Akka.net versus microsoft orleansBill Tulloch

CSP: Huh? And ComponentsDaniel Fagnan

Ruby is dying. What languages are cool now?Michał Konarski

Web development basics (Part-6)Rajat Pratap Singh

Online game server on Akka.NET (NDC2016)Esun Kim

Fast, concurrent ruby web applications with EventMachine and EM::SynchronyKyle Drake

Combining the strength of erlang and RubyMartin Rehfeld

Actors Set the Stage for Project Orleanscjmyers

About Clackfukamachi

Akka ActorsDylan Forciea

Rethinking the debuggerIulian Dragos

Functional Programming in ClojureTroy Miles

Erlang factory SF 2011 "Erlang and the big switch in social games"Paolo Negri

Elixir PhoenixTanuj Soni

Introduction to the Actor ModelBoldRadius Solutions

How to start using ScalaNgoc Dao

Introducing AkkaJonas Bonér

Introduction to Actor Model and AkkaYung-Lin Ho

Akka FundamentalsMichael Kendra

Akka frameworkmitesh_sharma

Akka.net versus microsoft orleansBill Tulloch

CSP: Huh? And ComponentsDaniel Fagnan

Ruby is dying. What languages are cool now?Michał Konarski

Web development basics (Part-6)Rajat Pratap Singh

Online game server on Akka.NET (NDC2016)Esun Kim

Fast, concurrent ruby web applications with EventMachine and EM::SynchronyKyle Drake

Combining the strength of erlang and RubyMartin Rehfeld

Actors Set the Stage for Project Orleanscjmyers

About Clackfukamachi

Akka ActorsDylan Forciea

Rethinking the debuggerIulian Dragos

Functional Programming in ClojureTroy Miles

Erlang factory SF 2011 "Erlang and the big switch in social games"Paolo Negri

Elixir PhoenixTanuj Soni

Introduction to the Actor ModelBoldRadius Solutions

Viewers also liked (20)

Akka Actor presentationGene Chang

Introduction to AkkaJohan Andrén

Akka - A Brief IntroThomas Lockney

The actor model provides simple concurrency, resiliency, and elasticity through processing messages sequentially between actors that have no shared state. Actors receive and respond to messages to define their behavior, and can create other actors within the actor system. Key aspects include that actors are not threads, messages are processed sequentially, multiple actors can work concurrently, and exception handling is done through hierarchical supervisor strategies.

Building Reactive Systems with Akka (in Java 8 or Scala)Jonas Bonér

Learn how to build Reactive Systems with Akka. Examples in both Java 8 and Scala. Abstract: The demands and expectations for applications have changed dramatically in recent years. Applications today are deployed on a wide range of infrastructure; from mobile devices up to thousands of nodes running in the cloud—all powered by multi-core processors. They need to be rich and collaborative, have a real-time feel with millisecond response time and should never stop running. Additionally, modern applications are a mashup of external services that need to be consumed and composed to provide the features at hand. We are seeing a new type of applications emerging to address these new challenges—these are being called Reactive Applications. In this talk we will introduce you to Akka and discuss how it can help you deliver on the four key traits of Reactive; Responsive, Resilient, Elastic and Message-Driven. We will start with the basics of Akka and work our way towards some of its more advanced modules such as Akka Cluster and Akka Persistence—all driven through code and practical examples.

Real Time Data Streaming using Kafka & StormRan Silberman

Is ruby logger thread(process)-safe? at RubyConf 2013Naotoshi Seo

This document discusses the thread and process safety of the Ruby Logger. It was found that while Logger is thread-safe due to use of a mutex, it is not process-safe as the mutex does not work across processes. The author contributed a fix to Ruby core that uses flock to lock access to logs across processes, ensuring process-safe logging. The fix will be included in Ruby 2.1.0, making the standard Ruby Logger thread and process-safe.

5分でわかるJRuby最新事情Naoto Takai

Threading and Concurrency in RubyTim Raymond

Rubyists generally tend to shy away from multi-threaded code. Cognitive overload, horror stories of threading bugs, and MRI's lack of native threading support are probably the reasons, but these are powerful constructs that every developer should understand. We'll tour the basic synchronization primitives that Ruby provides, and I'll show you where each is appropriate, covering potential pitfalls and hazards along the way. We'll see the strengths and limitations of the way MRI, Rubinius, and JRuby run our multithreaded code, and the implications that that has on our code's progress.

Ruby thread safety firstEmily Stolfo

1. There is no such thing as inherently thread-safe Ruby code as different Ruby implementations have different thread semantics. 2. Writing thread-safe code requires avoiding shared mutable state, and if needed, using concurrency primitives like Mutex and ConditionVariable to synchronize access to shared state. 3. Thoroughly testing concurrency involves testing with different Ruby implementations, a large number of threads, and synchronization patterns for precision.

Threads in Ruby (Basics)varunlalan

A thread is a lightweight process that shares resources with other threads in the same process. The document discusses using threads in Ruby by creating Thread objects and joining them. It demonstrates a race condition that can occur when multiple threads access shared variables without synchronization. To avoid this, the document introduces Mutex locks that allow only one thread to access a shared resource at a time, preventing race conditions.

Concurrent Programming with Ruby and Tuple Spacesluccastera

Ruby threads are limited due to the Global Interpreter Lock. Therefore, the best way to do parallel computing with Ruby is to use multiple processes but how do you get these processes to communicate? This session will provide some strategies for handling multi-process communication in Ruby, with a focus on the use of TupleSpaces. A TupleSpace provides a repository of tuples that can be accessed concurrently to implement a Blackboard system. Ruby ships with a built-in implementation of a TupleSpace with the Rinda library. During the session, Luc will demonstrate how to use Rinda and will highlight other libraries/projects that facilitate interprocess communication and parallel computing in Ruby.

JRuby on Rails and Thread SafetyNaoto Takai

The document discusses thread safety in JRuby on Rails applications. It explains that prior to Rails 2.2, each JRuby instance had its own database connection, but newer versions use connection pooling so multiple threads can share database connections through a single JRuby instance. It also covers using ActiveRecord connection pooling and JNDI lookup to configure database connections in a thread-safe way when using JRuby on Rails.

Scaling Ruby with Evented I/O - Ruby undergroundOmer Gazit

Ruby is considered by many to be slow and unscalable. In this talk we’ll try to disprove this premise by introducing EventMachine. We will cover the basic concepts of evented I/O programming and the Reactor pattern. Talk about best practices and useful libraries for EventMachine and see how to test your event driven code. Code examples from the presentation can be found at: https://github.com/omerisimo/em_underground

Akka - Developing SEDA Based ApplicationsBenjamin Darfler

This document discusses how to develop applications using the Staged Event Driven Architecture (SEDA) model with Akka. It describes how to decompose an application into stages connected by message queues, and how Akka actors can be used to implement the individual stages. Backpressure is discussed as important to prevent out of memory errors from message backups. Various Akka configuration options are presented for dispatchers, mailboxes, routing, and fault tolerance.

Multi-threaded web crawler in RubyPolcode

This document discusses how to build a multi-threaded web crawler in Ruby to drastically increase efficiency. It introduces the key components of threads, queues, and mutexes. It then outlines the components of the web crawler app: a Crawler module to set up the environment and database connection, Crawler::Threads class to spawn threads and queue jobs, and models to store retrieved data. Running the crawler with 10 threads completes the same task of visiting 10 pages in 1.51 seconds compared to 10 seconds for a single thread. The document also discusses ensuring thread safety when outputting data.

Ruby Concurrency and EventMachineChristopher Spring

Storm and Cassandra T Jake Luciani

Real-Time Analytics with Kafka, Cassandra and StormJohn Georgiadis

LMAX ArchitectureStephan Schmidt

ReST Vs SOA(P) ... Yawnozten

This document discusses Representational State Transfer (REST) and compares it to Service Oriented Architecture (SOA). It provides background on the early web and how REST emerged as a set of constraints for networked applications. It notes that REST is not a technology, standard, or product, but rather an architectural style. The document discusses core REST concepts like resources, representations, and stateless interactions over the uniform interface of HTTP. It addresses some common misconceptions about REST and whether it is only suited for simple use cases.

Akka Actor presentationGene Chang

Introduction to AkkaJohan Andrén

Akka - A Brief IntroThomas Lockney

Building Reactive Systems with Akka (in Java 8 or Scala)Jonas Bonér

Real Time Data Streaming using Kafka & StormRan Silberman

Is ruby logger thread(process)-safe? at RubyConf 2013Naotoshi Seo

5分でわかるJRuby最新事情Naoto Takai

Threading and Concurrency in RubyTim Raymond

Ruby thread safety firstEmily Stolfo

Threads in Ruby (Basics)varunlalan

Concurrent Programming with Ruby and Tuple Spacesluccastera

JRuby on Rails and Thread SafetyNaoto Takai

Scaling Ruby with Evented I/O - Ruby undergroundOmer Gazit

Akka - Developing SEDA Based ApplicationsBenjamin Darfler

Multi-threaded web crawler in RubyPolcode

Ruby Concurrency and EventMachineChristopher Spring

Storm and Cassandra T Jake Luciani

Real-Time Analytics with Kafka, Cassandra and StormJohn Georgiadis

LMAX ArchitectureStephan Schmidt

ReST Vs SOA(P) ... Yawnozten

Similar to Actors and Threads (20)

Bringing Concurrency to Ruby - RubyConf India 2014Charles Nutter

The document discusses bringing concurrency to Ruby. It begins by defining concurrency and parallelism, noting that both are needed but platforms only enable parallelism if jobs can split into concurrent tasks. It reviews concurrency and parallelism in popular Ruby platforms like MRI, JRuby, and Rubinius. The document outlines four rules for concurrency and discusses techniques like immutable data, locking, atomics, and specialized collections for mutable data. It highlights libraries that provide high-level concurrency abstractions like Celluloid for actors and Sidekiq for background jobs.

Intro to elixir and phoenixJared Smith

JRuby: The Hard PartsCharles Nutter

The document discusses challenges in implementing the Ruby programming language on the Java Virtual Machine (JVM) using JRuby. It covers areas like parsing Ruby, implementing different interpreters and compilers, utilizing JVM tricks, ensuring compatibility with features like strings and fibers, and integrating native capabilities. The author also shares decisions they have made around these challenges and future work.

Modern Java Concurrency (OSCON 2012)Martijn Verburg

The document discusses modern Java concurrency. It introduces the topic and explains why developers may want to utilize modern Java concurrency features. It discusses the java.util.concurrent library and how it provides building blocks for concurrent and thread-safe code like ReentrantLock, Condition, ConcurrentHashMap. It provides examples of using constructs like CountDownLatch, ThreadPoolExecutor, ForkJoin to write concurrent applications in a safer and more performant way compared to traditional locking approaches.

Erlang, the big switch in social gamesWooga

Online games backend are challenging applications, a single user generates one http call every few seconds, usage volume can spike very quickly and balance between data read and write is close to 50/50 which make the use of write through cache or other common scaling approaches not so effective. Follow how in our quest for a better architecture to serve millions of games sessions daily and reduce our resource usage we took the decision to write in Erlang our third generation game backend, see how we’re leveraging the actor model in order to change how we use and conceive our persistency layer. See also how introducing Erlang as a new tool in a company is working out, what we found hard from an organizational and technical point of view, which obstacle we hit and how as technical guys we convinced our management to take the risk of bringing in house a different technology.

Concurrency & Parallel ProgrammingRamazan AYYILDIZ

Ruby Concurrency RealitiesMike Subelsky

This document discusses different approaches to concurrency in Ruby including processes, threads, actors, fibers, and events. Processes provide simple concurrency but require starting each process and can't share resources. Threads provide concurrency within a process but require careful use to avoid bugs. Actors and fibers provide lightweight concurrency models based on message passing. Events provide high-performance concurrency using an event loop but code can become complex. The best approach depends on specific needs and runtime.

C# Async/Await ExplainedJeremy Likness

The document discusses asynchronous programming with async and await in C#. It explains that async and await were introduced to address issues with threading like overhead and blocking. Async methods use threads efficiently from the thread pool rather than creating new threads. Await yields threads rather than blocking them. The document demonstrates async programming and best practices like using Task instead of async void. It recommends using async for I/O bound work since it can improve performance over synchronous code.

Performance and AbstractionsMetosin Oy

Tommi Reiman discusses optimizing Clojure performance and abstractions. He shares lessons learned from optimizing middleware performance and JSON serialization. Data-driven approaches can enable high performance while maintaining abstraction. Reitit is a new routing library that aims to have the fastest performance through techniques like compiled routing data. Middleware can also benefit from data-driven approaches without runtime penalties. Overall performance should be considered but not obsessively, as many apps do not require extreme optimization.

Scalable game-servers-tgcAshkan Saeedi Mazdeh

Real time system_performance_monTomas Doran

This document discusses using message queues and AMQP for real-time system performance monitoring and job queuing. It describes how message queues allow producers and consumers to communicate asynchronously. The author details their experience building a job server using RabbitMQ, Catalyst, and Web::Hippie to queue and monitor long-running jobs. While the system is still a work in progress, all the major components are there and it is in use in production.

Rails development environment talkReuven Lerner

Messaging, interoperability and log aggregation - a new frameworkTomas Doran

In this talk, I will talk about why log files are horrible, logging log lines, and more structured performance metrics from large scale production applications as well as building reliable, scaleable and flexible large scale software systems in multiple languages. Why (almost) all log formats are horrible will be explained, and why JSON is a good solution for logging will be discussed, along with a number of message queuing, middleware and network transport technologies, including STOMP, AMQP and ZeroMQ. The Message::Passing framework will be introduced, along with the logstash.net project which the perl code is interoperable with. These are pluggable frameworks in ruby/java/jruby and perl with pre-written sets of inputs, filters and outputs for many many different systems, message formats and transports. They were initially designed to be aggregators and filters of data for logging. However they are flexible enough to be used as part of your messaging middleware, or even as a replacement for centralised message queuing systems. You can have your cake and eat it too - an architecture which is flexible, extensible, scaleable and distributed. Build discrete, loosely coupled components which just pass messages to each other easily. Integrate and interoperate with your existing code and code bases easily, consume from or publish to any existing message queue, logging or performance metrics system you have installed. Simple examples using common input and output classes will be demonstrated using the framework, as will easily adding your own custom filters. A number of common messaging middleware patterns will be shown to be trivial to implement. Some higher level use-cases will also be explored, demonstrating log indexing in ElasticSearch and how to build a responsive platform API using webhooks. Interoperability is also an important goal for messaging middleware. The logstash.net project will be highlighted and we'll discuss crossing the single language barrier, allowing us to have full integration between java, ruby and perl components, and to easily write bindings into libraries we want to reuse in any of those languages.

Repeating History...On Purpose...with ElixirBarry Jones

An Introduction to the Laravel Framework (AFUP Forum PHP 2014)daylerees

This document is an introduction to the Laravel PHP framework presented by Dayle Rees. It discusses Laravel's history and growth from 2011 to present, how Rees became involved as an early user and contributor, and key features of Laravel like its dependency injection container, Eloquent ORM, queues, authentication, caching and more. It also promotes resources like Laravel Forge and Homestead for getting started with Laravel development.

Modern Java Concurrency (Devoxx Nov/2011)Martijn Verburg

The document discusses modern Java concurrency and provides examples of how to write concurrent code safely and take advantage of modern hardware. It introduces key concepts like the java.util.concurrent package, locks, conditions, concurrent data structures, executors and fork/join. Examples are provided for using constructs like CountDownLatch, LinkedBlockingQueue, thread pools and fork/join tasks. The overall message is that modern Java concurrency allows safer and faster concurrent programming compared to traditional approaches.

I see deadlocks : Matt Ellis - Techorama NL 2024citizenmatt

.NET has LOADS of options for executing code concurrently. Except, sometimes it’s a little confusing what to use - threads, tasks or async/await? What about Reactive Extensions, Dataflow or Channels? Wait, what even is Dataflow? I’ve never heard of Channels! And now we’ve got async enumerable as well?! And what’s the deal with Interlocked, SemaphoreSlim, and friends?! It’s all getting a bit much. In this talk, we’ll take a look at all the different ways you can do concurrent programming with C#, see how they work and when you’d choose one approach over another.

Introduction to multicore .pptRajagopal Nagarajan

Multicore processors are becoming prevalent due to the limitations of increasing single core clock speeds. This presents challenges for software to effectively utilize multiple cores. Functional programming is one option that avoids shared state and parallel access issues, but requires a significant mindset shift. Refactoring existing code using tools is another option to incrementally introduce parallelism. Hybrid approaches combining paradigms may also help transition. Key application areas currently benefiting include servers, scientific computing, and packet processing. However, significant existing code is not easily parallelized and performance gains have yet to be fully realized.

VoltDB and Erlang - Tech planet 2012Eonblast

VoltDB and Erlang: two very promising beasts, made for the new parallel world, but still lingering in the wings. Not only are they addressing todays challenges but they are using parallel architectures as corner stone of their new and surprising approach to be faster and more productive. What are they good for? Why are we working to team them up? Erlang promises faster implementation, way better maintenance and 4 times shorter code. VoltDB claims to be two orders of magnitude faster than its competitors. The two share many similarities: both are the result of scientific research and designed from scratch to address the new reality of parallel architectures with full force. This talk presents the case for Erlang as server language, where it shines, how it looks, and how to get started. It details Erlang's secret sauce: microprocesses, actors, atoms, immutable variables, message passing and pattern matching. (Note: for a longer version of this treatment of Erlang only see: Why Erlang? http://www.slideshare.net/eonblast/why-erlang-gdc-online-2012) VoltDB's inner workings are explained to understand why it can be so incredibly fast and still better than its NoSQL competitors. The well publicized Node.js benchmark clocking in at 695,000 transactions per second is described and the simple steps to get VoltDB up and running to see the prodigy from up close. Source examples are presented that show Erlang and VoltDB in action. The speaker is creator and maintainer of the Erlang VoltDB driver Erlvolt.

Torquebox rubyhoedown-2012Lance Ball

Bringing Concurrency to Ruby - RubyConf India 2014Charles Nutter

Intro to elixir and phoenixJared Smith

JRuby: The Hard PartsCharles Nutter

Modern Java Concurrency (OSCON 2012)Martijn Verburg

Erlang, the big switch in social gamesWooga

Concurrency & Parallel ProgrammingRamazan AYYILDIZ

Ruby Concurrency RealitiesMike Subelsky

C# Async/Await ExplainedJeremy Likness

Performance and AbstractionsMetosin Oy

Scalable game-servers-tgcAshkan Saeedi Mazdeh

Real time system_performance_monTomas Doran

Rails development environment talkReuven Lerner

Messaging, interoperability and log aggregation - a new frameworkTomas Doran

Repeating History...On Purpose...with ElixirBarry Jones

An Introduction to the Laravel Framework (AFUP Forum PHP 2014)daylerees

Modern Java Concurrency (Devoxx Nov/2011)Martijn Verburg

I see deadlocks : Matt Ellis - Techorama NL 2024citizenmatt

Introduction to multicore .pptRajagopal Nagarajan

VoltDB and Erlang - Tech planet 2012Eonblast

Torquebox rubyhoedown-2012Lance Ball

Recently uploaded (20)

AI EngineHost Review: Revolutionary USA Datacenter-Based Hosting with NVIDIA ...SOFTTECHHUB

I started my online journey with several hosting services before stumbling upon Ai EngineHost. At first, the idea of paying one fee and getting lifetime access seemed too good to pass up. The platform is built on reliable US-based servers, ensuring your projects run at high speeds and remain safe. Let me take you step by step through its benefits and features as I explain why this hosting solution is a perfect fit for digital entrepreneurs.

Dev Dives: Automate and orchestrate your processes with UiPath MaestroUiPathCommunity

This session is designed to equip developers with the skills needed to build mission-critical, end-to-end processes that seamlessly orchestrate agents, people, and robots. 📕 Here's what you can expect: - Modeling: Build end-to-end processes using BPMN. - Implementing: Integrate agentic tasks, RPA, APIs, and advanced decisioning into processes. - Operating: Control process instances with rewind, replay, pause, and stop functions. - Monitoring: Use dashboards and embedded analytics for real-time insights into process instances. This webinar is a must-attend for developers looking to enhance their agentic automation skills and orchestrate robust, mission-critical processes. 👨‍🏫 Speaker: Andrei Vintila, Principal Product Manager @UiPath This session streamed live on April 29, 2025, 16:00 CET. Check out all our upcoming Dev Dives sessions at https://community.uipath.com/dev-dives-automation-developer-2025/.

Linux Professional Institute LPIC-1 Exam.pdfRHCSA Guru

Big Data Analytics Quick Research Guide by Arthur MorganArthur Morgan

This is a Quick Research Guide (QRG). QRGs include the following: - A brief, high-level overview of the QRG topic. - A milestone timeline for the QRG topic. - Links to various free online resource materials to provide a deeper dive into the QRG topic. - Conclusion and a recommendation for at least two books available in the SJPL system on the QRG topic. QRGs planned for the series: - Artificial Intelligence QRG - Quantum Computing QRG - Big Data Analytics QRG - Spacecraft Guidance, Navigation & Control QRG (coming 2026) - UK Home Computing & The Birth of ARM QRG (coming 2027) Any questions or comments? - Please contact Arthur Morgan at [email protected]. 100% human made.

AI Changes Everything – Talk at Cardiff Metropolitan University, 29th April 2...Alan Dix

Talk at the final event of Data Fusion Dynamics: A Collaborative UK-Saudi Initiative in Cybersecurity and Artificial Intelligence funded by the British Council UK-Saudi Challenge Fund 2024, Cardiff Metropolitan University, 29th April 2025 https://alandix.com/academic/talks/CMet2025-AI-Changes-Everything/ Is AI just another technology, or does it fundamentally change the way we live and think? Every technology has a direct impact with micro-ethical consequences, some good, some bad. However more profound are the ways in which some technologies reshape the very fabric of society with macro-ethical impacts. The invention of the stirrup revolutionised mounted combat, but as a side effect gave rise to the feudal system, which still shapes politics today. The internal combustion engine offers personal freedom and creates pollution, but has also transformed the nature of urban planning and international trade. When we look at AI the micro-ethical issues, such as bias, are most obvious, but the macro-ethical challenges may be greater. At a micro-ethical level AI has the potential to deepen social, ethnic and gender bias, issues I have warned about since the early 1990s! It is also being used increasingly on the battlefield. However, it also offers amazing opportunities in health and educations, as the recent Nobel prizes for the developers of AlphaFold illustrate. More radically, the need to encode ethics acts as a mirror to surface essential ethical problems and conflicts. At the macro-ethical level, by the early 2000s digital technology had already begun to undermine sovereignty (e.g. gambling), market economics (through network effects and emergent monopolies), and the very meaning of money. Modern AI is the child of big data, big computation and ultimately big business, intensifying the inherent tendency of digital technology to concentrate power. AI is already unravelling the fundamentals of the social, political and economic world around us, but this is a world that needs radical reimagining to overcome the global environmental and human challenges that confront us. Our challenge is whether to let the threads fall as they may, or to use them to weave a better future.

Network Security. Different aspects of Network Security.gregtap1

Salesforce AI Associate 2 of 2 Certification.docxJosé Enrique López Rivera

Role of Data Annotation Services in AI-Powered ManufacturingAndrew Leo

The Evolution of Meme Coins A New Era for Digital Currency ppt.pdfAbi john

"Client Partnership — the Path to Exponential Growth for Companies Sized 50-5...Fwdays

Asthma presentación en inglés abril 2025 pdfVanessaRaudez

Buckeye Dreamin' 2023: De-fogging Debug LogsLynda Kane

Drupalcamp Finland – Measuring Front-end Energy ConsumptionExove

SAP Modernization: Maximizing the Value of Your SAP S/4HANA Migration.pdfPrecisely

Learn the Basics of Agile Development: Your Step-by-Step GuideMarcel David

Enhancing ICU Intelligence: How Our Functional Testing Enabled a Healthcare I...Impelsys Inc.

#AdminHour presents: Hour of Code2018 slide deck from 12/6/2018Lynda Kane

Mobile App Development Company in Saudi ArabiaSteve Jonas

EmizenTech is a globally recognized software development company, proudly serving businesses since 2013. With over 11+ years of industry experience and a team of 200+ skilled professionals, we have successfully delivered 1200+ projects across various sectors. As a leading Mobile App Development Company In Saudi Arabia we offer end-to-end solutions for iOS, Android, and cross-platform applications. Our apps are known for their user-friendly interfaces, scalability, high performance, and strong security features. We tailor each mobile application to meet the unique needs of different industries, ensuring a seamless user experience. EmizenTech is committed to turning your vision into a powerful digital product that drives growth, innovation, and long-term success in the competitive mobile landscape of Saudi Arabia.

Automation Dreamin': Capture User Feedback From AnywhereLynda Kane

Rusty Waters: Elevating Lakehouses Beyond Sparkcarlyakerly1

Spark is a powerhouse for large datasets, but when it comes to smaller data workloads, its overhead can sometimes slow things down. What if you could achieve high performance and efficiency without the need for Spark? At S&P Global Commodity Insights, having a complete view of global energy and commodities markets enables customers to make data-driven decisions with confidence and create long-term, sustainable value. 🌍 Explore delta-rs + CDC and how these open-source innovations power lightweight, high-performance data applications beyond Spark! 🚀

AI EngineHost Review: Revolutionary USA Datacenter-Based Hosting with NVIDIA ...SOFTTECHHUB

Dev Dives: Automate and orchestrate your processes with UiPath MaestroUiPathCommunity

Linux Professional Institute LPIC-1 Exam.pdfRHCSA Guru

Big Data Analytics Quick Research Guide by Arthur MorganArthur Morgan

AI Changes Everything – Talk at Cardiff Metropolitan University, 29th April 2...Alan Dix

Network Security. Different aspects of Network Security.gregtap1

Salesforce AI Associate 2 of 2 Certification.docxJosé Enrique López Rivera

Role of Data Annotation Services in AI-Powered ManufacturingAndrew Leo

The Evolution of Meme Coins A New Era for Digital Currency ppt.pdfAbi john

"Client Partnership — the Path to Exponential Growth for Companies Sized 50-5...Fwdays

Asthma presentación en inglés abril 2025 pdfVanessaRaudez

Buckeye Dreamin' 2023: De-fogging Debug LogsLynda Kane

Drupalcamp Finland – Measuring Front-end Energy ConsumptionExove

SAP Modernization: Maximizing the Value of Your SAP S/4HANA Migration.pdfPrecisely

Learn the Basics of Agile Development: Your Step-by-Step GuideMarcel David

Enhancing ICU Intelligence: How Our Functional Testing Enabled a Healthcare I...Impelsys Inc.

#AdminHour presents: Hour of Code2018 slide deck from 12/6/2018Lynda Kane

Mobile App Development Company in Saudi ArabiaSteve Jonas

Automation Dreamin': Capture User Feedback From AnywhereLynda Kane

Rusty Waters: Elevating Lakehouses Beyond Sparkcarlyakerly1

Actors and Threads

1. Actors and Threads Safer Concurrency for Ruby Mike Perham @mperham

2. Who Am I? • Numerous gems (dalli, memcache-client, rack-ﬁber_pool, connection_pool, etc) • Scalability/Performance guy • Fibers and EventMachine • Technical Lead at Carbon Five

3. Ruby History • Fun! • Implementation • Performance • Scalability

4. What This Isn’t • Threads vs Events vs Processes • Threads won’t make you love Java

5. Deﬁnitions • Concurrency - performing two operations in tandem (e.g. two web requests) • Parallelism - performing two operations literally at the same time (requires two cores) Concurrent Parallel

6. Concurrency • Processes • Threads

7. The problem is always communication (true in the real world too!)

8. Communication • Two fundamental mechanisms • Share • Copy

10. IPC • Pipes • Sockets • Shared Memory • Files • POSIX 1988

11. IPC

12. Threads • Much more efﬁcient than processes • Communication mechanism? • Variables! • POSIX 1995

13. Threads

14. Threads

15. End Goals • Runtime Efﬁciency isn’t the only goal! • Remember Fun? • Ease of Development is huge

16. Locks • Hard to get right • Non-deterministic • Don’t scale

17. Locks

18. Lock Benchmark # Results: Ruby 1.9.2, GIL means no parallel threading # user system total real # single locked 4.310000 0.010000 4.320000 ( 4.311850) # threaded locked 4.230000 0.080000 4.310000 ( 4.307405) # # Results: JRuby 1.6.3, parallel threads mean massive lock contention # user system total real # single locked 4.080000 0.000000 4.080000 ( 4.080000) # threaded locked 17.109000 0.000000 17.109000 ( 17.109000) Context Switching!

19. Most Important Slide!

20. What can we do? • Look to other languages • Go • Scala • Erlang

21. Goroutines • Asynchronous function • You cannot get a handle to it • Send messages via a channel

22. Goroutines • Really like this model • Maps well to a distributed model • Backed by a pool of threads

23. Actors • unit of execution • has a mailbox • You just send it a message, e.g. • actor << { :amount => 11.99 }

24. Actors • Thread- or Fiber-backed • No application-level locks

25. Actor.rb • MRI/JRuby - no actors • Rubinius comes with actor.rb

26. Actor.rb

27. Actor.rb • Not idiomatic • Hard to understand, use correctly

28. Celluloid • Tony Arcieri (Revactor, Reia) • https://github.com/tarcieri/celluloid • OO Actors • Asynchronous method invocation • Mix of Threads and Fibers

29. Celluloid Example

30. Celluloid Thoughts • Nice, idiomatic Ruby design • One object == one thread • Needs actor pooling

31. girl_friday • yours truly • http://github.com/mperham/girl_friday • Background processing pools • Parallel batch operations • More functional than OO • Thread-based

32. girl_friday example

33. girl_friday example

34. What if we do need to share data?

35. I Love the 80s!

36. I Love the 00s!

37. STM • Software Transactional Memory • All mutation via transactions • Provide ACI (not ACID) guarantees • See Clojure (and Cloby!)

38. Atomic Instructions • Since Pentium (1993) • XCHG - swap registers or register/ memory • CPMXCHG - Compare And Set (‘CAS’)

39. Atomic!

40. Atomic Benchmark # Results: JRuby 1.6.3 # user system total real # single atomic 2.041000 0.000000 2.041000 ( 2.041000) # threaded atomic 0.978000 0.000000 0.978000 ( 0.979000) 2 cores = 2x speedup!

41. Atomic Structures • java.util.concurrent • ConcurrentHashMap • ConcurrentLinkedQueue

42. Conclusion

43. Concurrency It’s always hard! Modern languages should support tools and APIs that scale well AND are developer-friendly.

44. To Do • Need standard Actor API • Concurrent data structures • STM impl for Ruby (via JRuby?) • Multiverse

45. Further Reading • Kilim - Actors for Java • Disruptor - concurrency without locks • Actors in Scala • Concurrency in Erlang

46. Thank You! Questions? @mperham http://mikeperham.com http://blog.carbonﬁve.com PS We’re hiring!

Editor's Notes

#2: \n
#3: \n
#4: \n
#5: \n
#6: \n
#7: \n
#8: \n
#9: \n
#10: \n
#11: \n
#12: \n
#13: \n
#14: \n
#15: \n
#16: \n
#17: \n
#18: \n
#19: \n
#20: \n
#21: \n
#22: \n
#23: \n
#24: \n
#25: \n
#26: \n
#27: \n
#28: \n
#29: \n
#30: \n
#31: \n
#32: \n
#33: \n
#34: \n
#35: \n
#36: \n
#37: \n
#38: \n
#39: \n
#40: \n
#41: \n
#42: \n
#43: \n
#44: \n
#45: \n
#46: \n
#47: \n

Actors and Threads

Recommended

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Actors and Threads (20)

Recently uploaded (20)

Actors and Threads

Editor's Notes