What is channel buffer size?

I'm trying to create an asynchronous channel and I've been looking at http://golang.org/ref/spec#Making_slices_maps_and_channels.

c := make(chan int, 10)         // channel with a buffer size of 10

What does it mean that the buffer size is 10? What specifically does the buffer size represent/limit?

The buffer size is the number of elements that can be sent to the channel without the send blocking. By default, a channel has a buffer size of 0 (you get this with make(chan int)). This means that every single send will block until another goroutine receives from the channel. A channel of buffer size 1 can hold 1 element until sending blocks, so you'd get

c := make(chan int, 1)
c <- 1 // doesn't block
c <- 2 // blocks until another goroutine receives from the channel

The following code illustrates the blocking of unbuffered channel:

// to see the diff, change 0 to 1
c := make(chan struct{}, 0)
go func() {
	time.Sleep(2 * time.Second)
	<-c
}()
start := time.Now()
c <- struct{}{} // block, if channel size is 0
elapsed := time.Since(start)
fmt.Printf("Elapsed: %v\n", elapsed)

You may play with the code here.

package main

import (
	"fmt"
	"time"
)

func receiver(ch <-chan int) {
	time.Sleep(500 * time.Millisecond)
	msg := <-ch
	fmt.Printf("receive messages  %d from the channel\n", msg)
}

func main() {
	start := time.Now()
	zero_buffer_ch := make(chan int, 0)
	go receiver(zero_buffer_ch)
	zero_buffer_ch <- 444
	elapsed := time.Since(start)    
	fmt.Printf("Elapsed using zero_buffer channel: %v\n", elapsed)

	restart := time.Now()
	non_zero_buffer_ch := make(chan int, 1)
	go receiver(non_zero_buffer_ch)
	non_zero_buffer_ch <- 4444
	reelapsed := time.Since(restart)
	fmt.Printf("Elapsed using non zero_buffer channel: %v\n", reelapsed)
}

result:

receive messages 444 from the channel

Elapsed using zero_buffer channel: 505.6729ms

Elapsed using non zero_buffer channel: 0s