Channels and Communication

18. Channels and Communication

ch := make(chan int)          // Create an unbuffered channel for integers

ch <- 42      // Send value 42 to the channel
value := <-ch          // Receive a value from the channel

Unbuffered Channels:

An unbuffered channel ensures synchronization between the sender and the receiver. Sending and receiving happen concurrently, and both sides block until data is ready.

func main() {
    ch := make(chan int)

    go func() {
        ch <- 42             // Send value 42 to the channel
    }()

    value := <-ch          // Receive the value from the channel
    fmt.Println(value)    // Output: 42
}

Buffered Channels:

A buffered channel allows multiple values to be stored before blocking. When the buffer is full, sending will block until space is available. Receiving blocks when the buffer is empty.

func main() {
    ch := make(chan int, 2)                        // Create a buffered channel with capacity 2

    ch <- 42                                  // Send value 42 to the channel
    ch <- 43                                  // Send value 43 to the channel

    fmt.Println(<-ch)                       // Receive and print the first value
    fmt.Println(<-ch)                       // Receive and print the second value
}

Closing Channels:

Closing a channel indicates that no more values will be sent. Receivers can use the second return value to detect if a channel has been closed.

close(ch)      // Close the channel

value, ok := <-ch
if !ok {
    fmt.Println("Channel is closed")
}

Select Statement:

The 'select' statement allows you to wait on multiple channel operations. It's used to prevent goroutines from blocking indefinitely.

func main() {
    ch1 := make(chan int)
    ch2 := make(chan int)

    go func() {
        ch1 <- 42
    }()
    
    go func() {
        ch2 <- 43
    }()
    
    select {
    case value := <-ch1:
        fmt.Println("Received from ch1:", value)
    case value := <-ch2:
        fmt.Println("Received from ch2:", value)
    }
}

Summary:

• Channels enable safe communication and synchronization between goroutines.
• Use  'make(chan type)' to create a channel of a specific data type.
• Sending data to a channel is done using the '<-'operator.
• Receiving data from a channel is done using the '<-' operator as well.
• Unbuffered channels ensure synchronization between sender and receiver.
• Buffered channels allow multiple values to be stored before blocking.
• Closing a channel indicates that no more values will be sent.
• The 'select'  statement is used to wait on multiple channel operations.

Understanding channels and communication is essential for building concurrent programs in Go. Channels provide a structured way to coordinate goroutines and safely exchange data, making it easier to write efficient and synchronized concurrent code.