Core.async <!通道死锁

Question

为什么 Alpha 会提前停止，而我希望它的行为像 Beta 一样？ Alpha 和 Beta 之间的唯一区别是 >! 和 put!，如下所述。

阿尔法：

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=>

测试版：

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=>

同样有趣的是，在执行 Alpha 后，通道 #'user/q 被正确排队：

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

相同的结果出现在 Clojure 和 Clojurescript 中。这是某种僵局，还是假设会发生？

Answer 1

这是预期的。

通道 q 是在没有缓冲区的情况下创建的，因此当使用 >! 放置值时，它将阻塞（停放）go-loop 直到另一个线程准备好使用<!.

的值

解决这个问题的一种方法是给 q 一个带 (def q (chan 1)) 的单槽缓冲区。缓冲区允许在通道中放置 1 个值而不阻塞发送方。

Beta 的行为不同，因为 put! 是异步的。调用者——它使用一个单独的线程将新值放入通道中。这样可以避免阻塞当前go-loop，允许通道被读取并继续进行。

Core.async <!通道死锁

Core.async <! channel deadlock

clojure

clojurescript

core.async