如果多个订阅者在core.async通道上阻塞，那么在保证值时取出值的顺序是什么？

Question

Given an unbuffered core.async channel (or buffered, it shouldn't really matter), if multiple subscribers all wait on the channel, what is the order in which they take out the incoming messages? For example

(take! ch #(println "callback " 1 " got value " %))
(Thread/sleep 1000)
(take! ch #(println "callback " 2 " got value " %))
(Thread/sleep 1000)
(take! ch #(println "callback " 3 " got value " %))
(Thread/sleep 1000)

(put! ch 'a)
(put! ch 'b)
(put! ch 'c)

It seems that the order in this case is always 1 a , 2 b , 3 c , but I'm not sure if this is guaranteed, or if I'm just getting lucky? The Thread/sleep is added only to make sure that the subscribers subscribe in the order 1 2 3 .

If the ordering is guaranteed in this case, are there any other cases with core.async , where the order of putting/taking things out of a channel is random? I remember hearing somewhere, that some part of core.async intentionally introduces randomess to avoid users depending on some ordering of events, but I'm not sure if this was in relation to put! and take! .

The reasony why I'm asking this is because I wanted to use core.async as a synchronization mechanism, since it's rather simple to use. But in order to do that, I need to know if it'd actually synchronize anything, or introduce more randomness and non-determinism.

Answer 1

The docstrings to take! and put! make it explicitly clear that these are asynchronous operations, hence the API does not promise any order.

You have to either pass continuations to take! and put! or use the synchronous equivalents <!! / >!! ( <! / >! in a go block).