Channel creation in Go - Mini Project: Build & Apply

Channel creation

📖 Scenario: You are building a simple Go program that uses channels to communicate between goroutines. Channels are like pipes that let you send and receive data safely between different parts of your program.

🎯 Goal: Create a Go program that sets up a channel to send and receive integer values.

📋 What You'll Learn

Create a channel of type int called numbers

Create a variable called bufferSize and set it to 3

Use the make function with bufferSize to create a buffered channel

Print the channel variable numbers to show it was created

💡 Why This Matters

🌍 Real World

Channels are used in Go programs to safely pass data between different parts of a program running at the same time.

💼 Career

Understanding channels is important for Go developers working on concurrent or parallel applications, such as web servers or data processing pipelines.

1

Create a channel variable

Create a channel variable called numbers of type chan int without initializing it.

Go

var numbers chan int
// Your code here

Hint

Use var numbers chan int to declare a channel variable without creating it yet.

2

Add a buffer size variable

Create an integer variable called bufferSize and set it to 3.

Go

package main

import "fmt"

func main() {
    var numbers chan int
    bufferSize := 3
    // Your code here
}

Hint

Use bufferSize := 3 to create and set the variable in one line.

3

Initialize the buffered channel

Use the make function with bufferSize to create a buffered channel and assign it to numbers.

Go

package main

import "fmt"

func main() {
    var numbers chan int
    bufferSize := 3
    numbers = make(chan int, bufferSize)
    // Your code here
}

Hint

Use numbers = make(chan int, bufferSize) to create a buffered channel.

4

Print the channel variable

Write a fmt.Println statement to print the numbers channel variable.

Go

package main

import "fmt"

func main() {
    var numbers chan int
    bufferSize := 3
    numbers = make(chan int, bufferSize)
    fmt.Println(numbers)
    // Your code here
}

Hint

Use fmt.Println(numbers) to print the channel. The output will show the channel's memory address.

Practice

1. What is the correct way to create an unbuffered channel of integers in Go?

easy

A. ch := chan int{}

B. ch := new(chan int)

C. ch := make(chan int)

D. ch := make(int chan)

Solution

1. Step 1: Understand channel creation syntax

   Channels are created using the built-in make function with the syntax make(chan Type).

2. Step 2: Identify the correct option

   ch := make(chan int) uses make(chan int), which is the correct syntax for an unbuffered integer channel.

3. Final Answer:

   ch := make(chan int) -> Option C

4. Quick Check:

   make(chan int) = correct channel creation [OK]

Hint: Use make(chan Type) to create channels in Go [OK]

Common Mistakes:

• Using new(chan int) instead of make
• Incorrect syntax like chan int{}
• Swapping order in make(int chan)

2. Which of the following creates a buffered channel of strings with capacity 5?

easy

A. ch := make(chan string, cap=5)

B. ch := make(chan string, 5)

C. ch := make(chan string, "5")

D. ch := make(chan string)

Solution

1. Step 1: Recall buffered channel syntax

   Buffered channels are created by passing a second argument to make, which is the capacity (an integer).

2. Step 2: Identify the correct option

   ch := make(chan string, 5) correctly uses make(chan string, 5) to create a buffered string channel with capacity 5.

3. Final Answer:

   ch := make(chan string, 5) -> Option B

4. Quick Check:

   make(chan string, 5) = buffered channel [OK]

Hint: Add capacity as second arg in make for buffered channels [OK]

Common Mistakes:

• Omitting capacity for buffered channel
• Using string instead of int for capacity
• Incorrect syntax with named parameters

3. What will be the output of this Go code?

ch := make(chan int, 2)
ch <- 10
ch <- 20
fmt.Println(<-ch)
fmt.Println(<-ch)

medium

A. 10
20

B. 20
10

C. 10
10

D. Compilation error

Solution

1. Step 1: Understand buffered channel behavior

   The channel has capacity 2, so it can hold two values without blocking. Values 10 and 20 are sent in order.

2. Step 2: Read values from channel in FIFO order

   Receiving from the channel returns values in the order sent: first 10, then 20.

3. Final Answer:

   10 20 -> Option A

4. Quick Check:

   Buffered channel FIFO order = 10 then 20 [OK]

Hint: Buffered channels output values in send order (FIFO) [OK]

Common Mistakes:

• Assuming output reverses order
• Expecting runtime or compile error
• Confusing buffered with unbuffered channel behavior

4. Identify the error in this Go code snippet:

ch := make(chan int)
ch <- 5
fmt.Println(<-ch)

medium

A. Deadlock: sending on unbuffered channel without receiver

B. Syntax error in channel creation

C. Cannot print channel value directly

D. No error, code runs fine

Solution

1. Step 1: Analyze unbuffered channel send

   Unbuffered channels block the sender until a receiver is ready. Here, send happens before receive.

2. Step 2: Identify deadlock situation

   Since no goroutine is receiving concurrently, the send blocks forever causing deadlock.

3. Final Answer:

   Deadlock: sending on unbuffered channel without receiver -> Option A

4. Quick Check:

   Unbuffered send blocks without receiver = deadlock [OK]

Hint: Unbuffered send blocks until receive happens [OK]

Common Mistakes:

• Thinking code compiles but runs fine
• Confusing syntax error with runtime deadlock
• Assuming print causes error

5. You want to create a channel that can hold up to 3 float64 values without blocking the sender immediately. Which code snippet correctly does this and sends three values safely?

hard

A. ch := make(chan float64, 3)
<-ch
<-ch
<-ch

B. ch := make(chan float64)
ch <- 1.1
ch <- 2.2
ch <- 3.3

C. ch := make(chan float64, 2)
ch <- 1.1
ch <- 2.2
ch <- 3.3

D. ch := make(chan float64, 3)
ch <- 1.1
ch <- 2.2
ch <- 3.3

Solution

1. Step 1: Create buffered channel with capacity 3

   Use make(chan float64, 3) to create a channel that can hold 3 float64 values without blocking.

2. Step 2: Send three values safely

   Sending three values to this buffered channel will not block because capacity matches the number of sends.

3. Final Answer:

   ch := make(chan float64, 3) ch <- 1.1 ch <- 2.2 ch <- 3.3 -> Option D

4. Quick Check:

   Buffered channel capacity 3 allows 3 sends without blocking [OK]

Hint: Buffer size must match or exceed sends to avoid blocking [OK]

Common Mistakes:

• Using unbuffered channel for multiple sends
• Buffer smaller than sends causing deadlock
• Receiving before sending without goroutine