As we saw in the last lesson, concurrency in Go is incredibly easy to achieve using the Go keyword. However, whilst invoking concurrency is simple, managing it within your application requires a little more thought, especially when it comes to synchronisation through the use of a wait group or managing shared state and data, which will often require the use of a mutex.

However, Go actually does provide a construct that makes both managing state and synchronisation simple, one that allows you to pass data between Go routines in a way that's safe and synchronised. That construct is known as channels, which you can think of as being pipes that connect two concurrent Go routines, allowing you to send values from one Go routine and receive them on another. They're also an incredibly integral part when it comes to concurrency in Go.

---

Simple Example

Before we look at how we can add channels into our current application in order to remove the shared state, let's take a look at a simple example of how we can use them.

Here I have a really simple project with a main function. Inside of this main function, I'm calling a Go routine of an anonymous function, which inside is iterating from 0 to 9, using a for loop ranging up to 10.

Let's say I want to be able to access the values that this Go routine is producing on my main thread. Here, let's say here, here I want to get 0 to 9. Of course, I could just iterate from 0 to 9 on this main Go routine, but bear with me. Let's say I want to get this data from another thread that's potentially doing some calculations.

Rather than writing these values to a slice that lives on the main thread, such as follows, which again means we would have to consider things such as synchronisation, as well as ensuring that we're not mutating shared state, we can instead make use of a channel.

To do so, let's first define a new variable called ch. Then in order to instantiate a channel, we can use the make keyword, passing in the chan type.

ch := make(chan int)

The chan type also takes a second type value, which is the value type that you're going to be passing through this channel. This type can be anything you want, be it a primitive, such as a string, or a bool, or even your own defined type. In this case, say I had a struct called foo. In our case, we only want to pass an integer value, so we can specify this type to be a chan of int.

Then in order to actually write to this channel, we can use the following syntax, which writes the value of i onto the channel ch.

ch <- i

We'll talk more about this syntax in a second. For the meantime, let's take a look at how we can pull values from this channel now that they're being written. To do so, we can use the following syntax:

val := <-ch

This is very similar to the write syntax we saw on line 8. In this case, however, we're using the read syntax, which is an arrow pointing away from the channel. This syntax can be a little confusing at first to remember which one is which.

However, the way that I like to remember it is to consider the flow of data in relation to the channel's name. For example, on line 8, the arrow is pointing away from the value into the channel, meaning the flow of data is coming from the value itself into the channel, i.e., you're writing to it. Then on line 12, the arrow is pointing out of the channel, i.e., the data is coming from the channel into the value you're specifying. This to me makes it a little easier to understand what's actually going on.

Now that we have the value coming out of the channel, let's go ahead and print it to the console using the println statement of the fmt package, which looks as follows:

fmt.Println(val)

Now if I open up a new terminal window and run the go run main.go command, you can see we're printing out the value of zero, which was being generated from the other Go routine.

---

Reading Multiple Values

This is very cool, but how do we get all of the values being written to the channel?

You could of course use a for loop as follows:

for {
	val := <-ch
	// do something
}

But there's no exit condition in this situation, so the loop will just occur indefinitely.

We could hack together an exit condition, checking the value is equal to 9, and then calling the break keyword. However, this isn't exactly scalable, especially if we happen to change the value of our range, and additionally requires us to know the exact values that are going to come through, which isn't always the case.

However, because the channel type works with the range keyword, we can just use that instead:

for val := range ch {
	fmt.Println(val)
}

Now if I go ahead and run this code using the go run main.go command, let me make this just a little bigger. Now if we go ahead and run this code, you can see it prints zero to nine, but we get a deadlock error, causing our code to crash.

---

Closing the Channel

This happens because we actually still have no exit condition. We're still technically running in an infinite loop.

We need a way to tell the channel that there's no more data going to be received on it, which will cause this for loop to exit.

To do this in Go, you use the close function:

close(ch)

Now when I go ahead and run this code using the go run main command, you can see we print zero to nine and we exit successfully.

⚠️ Once a channel has been closed, you can't write any more data to it. Doing so will panic.

Therefore, it's imperative to make sure that a close takes place at the end of all your write operations, which means it's a good candidate to use with the defer keyword.

---

Using Channels in Our Application

We want to replace:

• the line where we're adding our count to our totals
• and where we're printing it out to the console

To do so, let's first create a new channel:

results := make(chan counter.Counts)

Then inside of our Go routine, write to the channel:

results <- count

Next, underneath our loop, use:

for res := range results {
    totals.Add(res)
    res.Print(...)
}

---

Passing Multiple Values in a Channel

However, when I do so, you'll notice we have an error, letting us know that our fileName is undefined.

Because channels only support one type, we can’t pass two values to them.

Solution: Create a new type:

type fileCountResult struct {
    Count    counter.Counts
    FileName string
}

Then use:

results := make(chan fileCountResult)

Inside the goroutine:

results <- fileCountResult{
    Count: count,
    FileName: file,
}

Then read like:

for res := range results {
    totals.Add(res.Count)
    res.Count.Print(res.FileName, ...)
}

Remove the existing code where we were modifying the state inside of our Go routines, and also remove the sync.Mutex.

---

Fixing a Deadlock

If I run the code, we actually receive a deadlock.

We received our two results, but then the deadlock occurs. This is because we've forgotten to close the channel, which we need to do after all Go routines have completed.

We already have a wait group, so we can do:

go func() {
    wg.Wait()
    close(results)
}()

Now it works, and we’re no longer needing to use a mutex.

---

Final Notes

One thing I didn't cover too much in the last lesson but something we should talk about in this lesson is the fact that our didError statement is also being mutated across multiple Go routines.

However, this isn't too much of an issue. We're only ever setting this to true, which makes the operation idempotent — meaning it doesn’t matter how many times it happens or in what order.

---

With that, we've successfully managed to add channels into our code.

However, as you can tell, our code is getting a little messy. Therefore, in the next lesson we'll look a bit more at some of the properties when it comes to channels, whilst also performing some refactoring of our code.

As always, make sure to go ahead and commit your changes and I'll see you there.