CSP vs Actor model for concurrency

On this article, we’ll focus on how CSP and actor concurrency fashions work.

Speaking Sequential Processes (CSP)

Communicating Sequential Processes (CSP) is a mannequin put forth by Tony Hoare in 1978 which describes interactions between concurrent processes.
It made a breakthrough in Laptop Science, particularly within the subject of concurrency.

In CSP we use “channels” for communication and synchronization. Though there may be decoupling between the processes, they’re nonetheless coupled to the channel.

It’s totally synchronous, a channel author should block till a channel reader reads. The benefit of that blocking primarily based mechanism is {that a} channel solely must ever maintain one message. It is also in some ways simpler to purpose about.

CSP is applied in languages like Go together with goroutines and channels.

Actor mannequin


Actor model was put forth by Carl Hewitt in 1973 and it adopts the philosophy that every thing is an actor. That is just like the every thing is an object philosophy utilized by some object-oriented programming languages.

It’s inherently asynchronous, a message sender is not going to block whether or not the reader is able to pull from the mailbox or not, as an alternative the message goes right into a queue normally known as a “mailbox”. Which is handy, however it is a bit tougher to purpose about and mailboxes probably have to carry plenty of messages.

Every course of has a single mailbox, messages are put into the receiver’s mailbox by the sender, and fetched by the receiver.

Actor mannequin is applied in languages corresponding to Erlang and Scala. In Java world, Akka is often used for this.


Some variations between the actor mannequin and speaking sequential processes:

  • Processes in CSP are nameless, whereas actors have identities.
  • CSP makes use of channels for message passing, whereas actors use mailboxes.
  • Actor should solely talk via message supply, therefore making them stateless.
  • CSP messages are delivered within the order they have been despatched.
  • The actor mannequin was designed for distributed packages, so it might scale throughout a number of machines.
  • Actor mannequin is extra decoupled than CSP.


I feel each are implausible concurrency fashions and are fairly underrated. I am undecided why everybody simply went with the multi-threading hype and forgot about these fashions given they have been right here because the Seventies.

It’s nice to see languages like Go, Rust, Scala, and Elixir bringing these highly effective ideas again into the dialogue. Personally, I discover these fashions rather more pure than multi-threading, STM, Guilds, and so on.

Do you suppose one is healthier than the opposite? I would love to listen to your ideas.

Add a Comment

Your email address will not be published. Required fields are marked *