3. Channels Pt.2

In the previous lesson, we saw how we can receive values from channels like this:

v := <-ch

However, sometimes we don't care what is passed through a channel. We only care when and if something is passed. In that situation, we can block and wait until something is sent on a channel using the following syntax.

<-ch

This will block until it pops a single item off the channel, then continue, discarding the item.

In cases like this, Empty structs are often used as a unary value so that the sender communicates that this is only a "signal" and not some data that is meant to be captured and used by the receiver.

Here is an example:

func downloadData() chan struct{} {
	downloadDoneCh := make(chan struct{})

	go func() {
		fmt.Println("Downloading data file...")
		time.Sleep(2 * time.Second) // simulate download time

		// after the download is done, send a "signal" to the channel
		downloadDoneCh <- struct{}{}
	}()

	return downloadDoneCh
}

func processData(downloadDoneCh chan struct{}) {
	// any code here can run normally
	fmt.Println("Preparing to process data...")

	// block until `downloadData` sends the signal that it's done
	<-downloadDoneCh

	// any code here can assume that data download is complete
	fmt.Println("Data download complete, starting data processing...")
}

processData(downloadData())
// Preparing to process data...
// Downloading data file...
// Data download complete, starting data processing...

Channels - Signaling Without Data

Receiving Without Storing

Normal Receive (Store the Value)

v := <-ch  // Receive and store in v

Signal Receive (Discard the Value)

<-ch  // Receive and discard, just wait for signal

This blocks until something is sent, then continues without storing the value.

Why Use This?

When you only care that something happened, not what was sent.

Examples:

• "Download is done"

• "Task completed"

• "Ready to proceed"

Empty Struct: struct{}

The empty struct takes up zero bytes of memory:

chan struct{}

Perfect for signaling because:

• No data needed

• Zero memory cost

• Clear intent: "this is just a signal"

Creating and Sending Empty Struct

Create channel:

ch := make(chan struct{})

Send empty struct:

ch <- struct{}{}
      ^^^^^^^^
      |      └─ Initialize empty struct
      └─ Type: struct{}

Receive (wait for signal):

<-ch  // Block until signal received

Complete Example Breakdown

func downloadData() chan struct{} {
    downloadDoneCh := make(chan struct{})
    
    go func() {
        fmt.Println("Downloading data file...")
        time.Sleep(2 * time.Second)  // Simulate work
        
        downloadDoneCh <- struct{}{}  // Send signal: "I'm done!"
    }()
    
    return downloadDoneCh
}

func processData(downloadDoneCh chan struct{}) {
    fmt.Println("Preparing to process data...")
    
    <-downloadDoneCh  // Wait for signal
    
    fmt.Println("Data download complete, starting data processing...")
}

func main() {
    processData(downloadData())
}

Output:

Preparing to process data...
Downloading data file...
Data download complete, starting data processing...

Flow Diagram

Main Thread                 |  Goroutine
───────────────────────────┼──────────────────────
Create channel              |
Start goroutine ────────────┼─→ Start downloading
Continue to processData     |
Print "Preparing..."        |  Print "Downloading..."
Wait at <-downloadDoneCh ───┼── Sleep 2 seconds
(blocked)                   |
                            |  Send struct{}{} signal
Receive signal ←────────────┼──
Print "Starting..."         |  Goroutine ends

Real-World Example: Multiple Workers

func worker(id int, done chan struct{}) {
    fmt.Printf("Worker %d starting\n", id)
    time.Sleep(time.Second)
    fmt.Printf("Worker %d done\n", id)
    done <- struct{}{}  // Signal completion
}

func main() {
    done := make(chan struct{})
    
    go worker(1, done)
    go worker(2, done)
    go worker(3, done)
    
    // Wait for all 3 workers
    <-done  // Wait for worker 1
    <-done  // Wait for worker 2
    <-done  // Wait for worker 3
    
    fmt.Println("All workers done!")
}

Comparison: With vs Without Data

With Data (Need the Result)

resultCh := make(chan int)

go func() {
    result := calculate()
    resultCh <- result  // Send the actual result
}()

answer := <-resultCh  // Store and use the result
fmt.Println("Result:", answer)

Without Data (Just Need to Know It's Done)

doneCh := make(chan struct{})

go func() {
    doWork()
    doneCh <- struct{}{}  // Just signal "done"
}()

<-doneCh  // Wait for signal, don't care about value
fmt.Println("Work complete!")

Understanding struct{}{}

struct{}{}
^^^^^^  ^^
  |     └─ Initialize (create an instance)
  └─ Type (empty struct)

Breakdown:

• struct{} = the type (empty struct)

• {} = create an instance of it

Other examples:

user{}           // Create empty user
user{name: "Bob"} // Create user with data
struct{}{}       // Create empty struct

Common Patterns

Pattern 1: Wait for Single Task

done := make(chan struct{})
go doTask(done)
<-done  // Block until task completes

Pattern 2: Wait for Multiple Tasks

done := make(chan struct{})

go task1(done)
go task2(done)

<-done  // Wait for first
<-done  // Wait for second

Pattern 3: Notify When Ready

ready := make(chan struct{})

go func() {
    setupServer()
    close(ready)  // Signal ready by closing
}()

<-ready  // Wait until setup complete
startAcceptingRequests()

Why Not Just Use bool?

You could, but struct{} is better:

Using bool:

done := make(chan bool)
done <- true  // What does true mean? false would work too

Using struct{}:

done := make(chan struct{})
done <- struct{}{}  // Clear: just a signal, no data

Benefits:

• Zero memory

• Clear intent

• Can't accidentally interpret the value

Key Takeaways

1

Receive-and-discard

<-ch without assignment receives and discards the value — use it to wait for a signal.

2

Empty struct is zero bytes

struct{}{} is an empty struct value that occupies 0 bytes.

3

Signal channels

chan struct{} is the common pattern for channels used purely for signaling.

4

Use case

Use signal channels to indicate completion or readiness, not to pass data.

5

Blocking behavior

Receiving from the channel blocks until a sender provides a signal.

Quick Reference

Operation	Syntax	Purpose
Create signal channel	make(chan struct{})	Channel for signaling
Send signal	ch <- struct{}{}	"Something happened"
Wait for signal	<-ch	Block until signal
Check type size	unsafe.Sizeof(struct{}{})	0 bytes

Remember: Use struct{} channels when you care that something happened, not what happened!

Assignment

Our Textio server isn't able to boot up until it receives the signal that its databases are all online, and it learns about them being online by waiting for tokens (empty structs) on a channel.

Run the code. It never exits! The channel passed to waitForDBs stays blocked, because it's only popping the first value off the channel.

Fix the waitForDBs function. It should pause execution until it receives a token for every database from the dbChan channel. Each time waitForDBs reads a token, the getDBsChannel goroutine will print a message to the console for you. The succinctly named numDBs input is the total number of databases. Look at the test code to see how these functions are used so you can understand the control flow.

package main

import "fmt"

func waitForDBs(numDBs int, dbChan chan struct{}) {
	
	<-dbChan
}

// don't touch below this line

func getDBsChannel(numDBs int) (chan struct{}, *int) {
	count := 0
	ch := make(chan struct{})

	go func() {
		for i := 0; i < numDBs; i++ {
			ch <- struct{}{}
			fmt.Printf("Database %v is online\n", i+1)
			count++
		}
	}()

	return ch, &count
}

Solution

package main

import "fmt"

func waitForDBs(numDBs int, dbChan chan struct{}) {

	for i:=0; i<numDBs; i++ {
		<-dbChan
	}
}

// don't touch below this line

func getDBsChannel(numDBs int) (chan struct{}, *int) {
	count := 0
	ch := make(chan struct{})

	go func() {
		for i:= 0; i < numDBs; i++ {
			ch <- struct{}{}
			fmt.Printf("Database %v is online\n", i+1)
			count++
		}
	}()

	return ch, &count
}

The Problem

func waitForDBs(numDBs int, dbChan chan struct{}) {
    <-dbChan  // ❌ Only receives ONE signal, but there are numDBs signals
}

Currently, it only waits for the first database, then returns. But you need to wait for all databases.

The Solution

You need to receive numDBs times:

func waitForDBs(numDBs int, dbChan chan struct{}) {
    for i := 0; i < numDBs; i++ {
        <-dbChan
    }
}

Why This Works

Example with 3 databases:

// getDBsChannel sends 3 signals
ch <- struct{}{}  // Database 1
ch <- struct{}{}  // Database 2
ch <- struct{}{}  // Database 3

// waitForDBs receives 3 times
<-dbChan  // Receive signal 1
<-dbChan  // Receive signal 2
<-dbChan  // Receive signal 3
// Now all databases are online, function returns

Step-by-Step Flow

Goroutine (getDBsChannel)    |  Main (waitForDBs)
─────────────────────────────┼────────────────────────
Send signal for DB 1 ────────┼─→ Receive (i=0)
Print "Database 1 online"    |
                             |
Send signal for DB 2 ────────┼─→ Receive (i=1)
Print "Database 2 online"    |
                             |
Send signal for DB 3 ────────┼─→ Receive (i=2)
Print "Database 3 online"    |
                             |
Goroutine ends               |  Loop ends, return

Expected Output

Database 1 is online
Database 2 is online
Database 3 is online

(Assuming numDBs = 3)

Why Your Original Code Blocked Forever

<-dbChan  // Receives first signal
// Function returns immediately
// But getDBsChannel is still trying to send 2 more signals
// No one is receiving those signals → deadlock

The goroutine tries to send all signals, but after the first one, there's no receiver, so it blocks forever.

Complete Solution

package main

import "fmt"

func waitForDBs(numDBs int, dbChan chan struct{}) {
    for i := 0; i < numDBs; i++ {
        <-dbChan
    }
}

// don't touch below this line

func getDBsChannel(numDBs int) (chan struct{}, *int) {
    count := 0
    ch := make(chan struct{})
    go func() {
        for i := 0; i < numDBs; i++ {
            ch <- struct{}{}
            fmt.Printf("Database %v is online\n", i+1)
            count++
        }
    }()
    return ch, &count
}

That's it! The key is looping numDBs times to receive all the signals.