（chan）和（chan 1）有什么区别？

Question

What is the difference between these two constructs? The Clojure docs mention that the latter adds a buffer. But it's not clear to me what that means.

Answer 1

The number creates a fixed buffer which is used to hold values, so when you use ie >!! it will block unless there is space in the buffer or something consumes immediatly.

So (chan) should be equivalent to (chan 0) - there is no buffer (buffer of size 0)

Instead of a number you could also supply a specific buffer, see here in the "see also" section.

Answer 2

If a channel is 'attached' to a go block that is always taking its values, then as soon as values are put into the channel they will be taken out again. If this is the case then the buffer size of the channel does not matter.

But consider the case where no such extractor exists:

(def zero-buf-chan (chan))
(defn two-into-zero []
  (go (>! zero-buf-chan :first)
      (println "First into zero completed - NOT SEEN until run zero extractor")
      (>! zero-buf-chan :second)
      (println "Second into zero completed - NOT SEEN until run zero extractor")))
(two-into-zero)

Here nothing will happen because zero-buf-chan has no room to accept input. The 'go block' here will be paused at the first line, waiting for a withdrawal.

If we now give the channel a size of 1 then it will have room to accept the first input, after which it will pause:

(def one-buf-chan (chan 1))  
(defn two-into-one []
  (go (>! one-buf-chan :first)
      (println "First into one completed - SEEN")
      (>! one-buf-chan :second)
      (println "Second into one completed - NOT SEEN until run one extractor")))
(two-into-one)

So now we will see

First into one completed - SEEN

in the console.

Now we have two paused go blocks. one-buf-chan has :first in it and zero-buf-chan is empty.

For completeness here are two methods that can be used to do the extracting:

(defn zero-extractor []
  (go (println "Got from zero at first try: " (<! zero-buf-chan))
      (println "Got from zero at second try: " (<! zero-buf-chan))))

(defn one-extractor []
  (go (println "Got from one at first try: " (<! one-buf-chan))
      (println "Got from one at second try: " (<! one-buf-chan))))

If you run these functions then all the println s will be seen and both channels will be emptied out. Notice that no data is ever lost. The size of the buffer just determines how early blocking will occur. And furthermore is it good to note that blocking is not blocking your program, but blocking ONLY within the go block.