Core.async

Question

Why does Alpha stop early, when I expect it to behave like Beta? The only difference between Alpha and Beta is >! and put! , as commented below.

Alpha:

user=> (def q (chan))
#'user/q
user=> (def counter (atom 0))
#'user/counter
user=> (defn mg [event-queue]
  #_=>      (go-loop [event (<! event-queue)]
  #_=>       (swap! counter inc)
  #_=>       (when (< @counter 4)
  #_=>         (println "counter: " @counter)
  #_=>         (>! event-queue {:a @counter})      ;; Here's the only difference
  #_=>         (println "event: " event)
  #_=>         (recur (<! event-queue)))))
#'user/mg
user=> (mg q)
#object[clojure.core.async.impl.channels.ManyToManyChannel 0x3a1ffd56 "clojure.core.async.impl.channels.ManyToManyChannel@3a1ffd56"]
user=> (put! q "hi")
counter:  true
1
user=>

Beta:

user=> (def q (chan))
#'user/q
user=> (def counter (atom 0))
#'user/counter
user=> (defn mg [event-queue]
  #_=>   (go-loop [event (<! event-queue)]
  #_=>    (swap! counter inc)
  #_=>    (when (< @counter 4)
  #_=>      (println "counter: " @counter)
  #_=>      (put! event-queue {:a @counter})      ;; Here's the only difference
  #_=>      (println "event: " event)
  #_=>      (recur (<! event-queue)))))
#'user/mg
user=> (mg q)
#object[clojure.core.async.impl.channels.ManyToManyChannel 0x72c9b65a "clojure.core.async.impl.channels.ManyToManyChannel@72c9b65a"]
user=> (put! q "hi")
true
counter:  1
event:  hi
counter:  2
event:  {:a 1}
counter:  3
event:  {:a 2}
user=> 

It's also interesting that, after executing Alpha, the channel #'user/q was properly enqueued:

user=> (take! q println)
event:  hi
{:a 1}
nil
user=> 

The same results occur in both Clojure and Clojurescript. Is this some sort of deadlock, or is the suppose to happen?

Answer 1

This is expected.

The channel q is created without a buffer, so when a value is placed with >! , it will block (park) the go-loop until another thread is ready to consume the value with <! .

One way to work around this is to give q a 1-slot buffer with (def q (chan 1)) . The buffer allows 1 value to be placed in the channel without blocking the sender.

Beta behaves differently because put! is asynchronous wrt. the caller -- it uses a separate thread to place the new value in the channel. This avoids blocking the current go-loop , allowing the channel to be read and progress to continue.