Bummer! This is just a preview. You need to be signed in with a Basic account to view the entire video.

Preview

Start a free Basic trial
to watch this video

Sign up for Treehouse

Channels

5:27 with Jay McGavren

Channels solve two problems simultaneously: they let your goroutines communicate with each other, and they let you synchronize your goroutines' operations.

Here's an updated version of our longTask function that takes a random number of seconds to complete. We're using the rand package to generate a random number. We've also updated longTask to return the number of seconds it took to its caller.

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func longTask() int {
    delay := rand.Intn(5)
    fmt.Println("Starting long task")
    time.Sleep(time.Duration(delay) * time.Second)
    fmt.Println("Long task finished")
    return delay
}

func main() {
    rand.Seed(time.Now().Unix())
    time := longTask()
    fmt.Println("Took", time, "seconds")
}
  • Suppose we want to call longTask as a goroutine. We can't just say time := go longTask(). We'll get a syntax error if we try to run this.
  • And even if that were allowed, what would we print in the like following the call to longTask? The goroutine doesn't return a value right away!
  • It's just not possible to communicate between goroutines using simple return values.

So instead, we're going to create a channel, and use that to communicate with our goroutine. The channel will allow longTask to pass a value back to the main goroutine. And when the main goroutine encounters the instruction to read from the channel, it will wait until it has a value to proceed.

  • We call the built-in make method to create a channel. The type for a channel is chan. And then we need to specify what type of values the channel will accept; we'll use int.
  • We're going to change longTask's declaration so it accepts a channel as an argument, and get rid of the return value. So we'll pass our new channel to longTask, get rid of the time variable, and call it as a goroutine.
  • Then, instead of printing the time variable, we'll read a value from the channel.
  • Then we'll change the longTask declaration to match the call in main. We'll accept a chan int parameter, and get rid of the return value.
  • Instead of returning the time we waited at the end of longTask, we're going to write that value to the channel. That value will then be received and printed down in main.
package main

import (
    "fmt"
    "math/rand"
    "time"
)

func longTask(channel chan int) { // Remove return value, accept channel chan int
    delay := rand.Intn(5)
    fmt.Println("Starting long task")
    time.Sleep(time.Duration(delay) * time.Second)
    fmt.Println("Long task finished")
    channel <- delay // Changed from "return delay"
}

func main() {
    rand.Seed(time.Now().Unix())
    channel := make(chan int) // Add
    go longTask(channel) // Change from "time := longTask()"
    fmt.Println("Took", <-channel, "seconds") // "<-channel" instead of "time"
}
  • We can start multiple goroutines if we want, and they can all write to the same channel.
  • Then as long as we read from the channel that same number of times, the program will wait until all goroutines have finished before it exits.
  for i := 1; i <= 3; i++ {
    go longTask(channel)
  }
  for i := 1; i <= 3; i++ {
    fmt.Println("Took", <-channel, "seconds")
  }
  • 0:00

    Here's an updated version of our longTask function

  • 0:02

    that takes a random number of seconds to complete.

  • 0:05

    We're using the Rand package to generate a random number.

  • 0:09

    Again, that's not really important to understand in Go routines.

  • 0:12

    But you can see the teacher's notes if you wanna learn more.

  • 0:15

    We've also updated LongTask to return the number of seconds it took to its caller.

  • 0:20

    So let's try running this here.

  • 0:21

    It says starting long task and this time it slept for one second.

  • 0:28

    Let's try running it again, and we can see this time it slept for 3 seconds.

  • 0:34

    So it sleeps for a random number of seconds each time.

  • 0:37

    You can see down here that we're taking the return value from long task,

  • 0:41

    the number of seconds that it slept for, storing it in a variable and

  • 0:44

    then printing that variable out to show the number of seconds that task took.

  • 0:49

    Now suppose we wanna call longTask as a go routine.

  • 0:52

    We can't just say time equals go longTask.

  • 0:55

    We'll get a syntax error if we try to run this.

  • 1:01

    Line 19, unexpected keyword go.

  • 1:04

    We were expecting an expression.

  • 1:07

    An even if that were allowed,

  • 1:08

    what would we print in the line following the call to longTask.

  • 1:12

    The go routine doesn't return the value right away.

  • 1:15

    It's just not possible to communicate between go routines using simple return

  • 1:19

    values.

  • 1:20

    So instead, we're going to create a channel, and

  • 1:22

    use that to communicate with our go routine.

  • 1:24

    The channel will allow longTask to pass a value back to the main go routine.

  • 1:29

    And when the main go routine encounters the instruction to read from the channel,

  • 1:33

    it will wait until it has a value before it proceeds.

  • 1:37

    We call the built-in make method to create a channel.

  • 1:42

    We need to pass the type of value we are going to create to make.

  • 1:46

    The type for a channel uses the abbreviation chan,

  • 1:49

    and then we need to specify what type of values the channels will accept.

  • 1:54

    We'll use a value of int in this case since we are going to

  • 1:57

    be passing an integer with the number of seconds we waited.

  • 2:00

    Then we'll store the new channel in a variable called channel.

  • 2:06

    We're going to change the longTask functions declaration so

  • 2:09

    that it accepts a channel as an argument, and get rid of the return value.

  • 2:13

    So we'll pass our new channel as an argument to longTask, Get rid

  • 2:18

    of the time variable and we'll cal longTask as a go routine.

  • 2:24

    Then, instead of printing the time variable,

  • 2:26

    we'll read a value from the channel.

  • 2:28

    We do that using the arrow syntax.

  • 2:33

    The arrow consists of a less than sign followed by a dash, and

  • 2:36

    you can think of it as an arrow pointing from the channel into your code.

  • 2:41

    Now we need to change the longTask methods declaration to match the code in main.

  • 2:46

    We'll accept the parameter named channel of type chan int.

  • 2:53

    That is,

  • 2:53

    its type is channel, and the type of value that the channel holds are int values.

  • 2:58

    And will get rid of the return value from longTask.

  • 3:02

    At the end of the longTask function, instead of returning the amount of time

  • 3:06

    we waited, we're going to write that value to the channel.

  • 3:10

    So we'll take our channel parameter, and

  • 3:12

    we'll use the arrow syntax to write a value to it.

  • 3:15

    Think of this as the arrow pointing to the channel.

  • 3:20

    That value will then be received and printed down in the main function.

  • 3:24

    So let's save this and try running it.

  • 3:29

    Starting long task, waiting for a random period.

  • 3:33

    The amount of time we waited got written to the channel, and

  • 3:36

    then it got printed out down in the main function.

  • 3:39

    Let's try running it again.

  • 3:41

    Starting with a long task.

  • 3:44

    Waits for a random period.

  • 3:46

    And it receives the amount of time it waited over the channel and

  • 3:48

    prints it out down in the main function.

  • 3:51

    Notice that each time the read from the channel down in the main function

  • 3:55

    causes the main go routine to wait until the longTask go routine completes.

  • 4:01

    We can start multiple go routines if we want.

  • 4:03

    And they can all write to the same channel.

  • 4:05

    So let's setup a loop here.

  • 4:07

    We'll say, for i =, we'll start it a 1 while i is less than or

  • 4:14

    equal to three increment i after each pass through the loop.

  • 4:22

    And then here within the loop we'll call longTask as a go routine.

  • 4:29

    So this will wind up calling longTask three times.

  • 4:32

    Then we'll create another for loop.

  • 4:36

    That uses the same parameters.

  • 4:39

    It'll start at one while it's less than or equal to three we'll increment it by one.

  • 4:44

    And within that loop we'll read from the channel

  • 4:49

    the number of seconds that our go routine took.

  • 4:53

    Let's save this and try running it.

  • 4:56

    We see that our three go routines start almost simultaneously.

  • 5:00

    Print starting long task three times.

  • 5:03

    Two of the Go routines took 3 seconds to complete, and

  • 5:07

    the third took 4 seconds to complete.

  • 5:10

    Because we read from the channel the same number of times that we wrote to it,

  • 5:14

    the program waits until all the Go routines have finished before it exits.

  • 5:18

    This is just been a quick taste of Go's concurrency features.

  • 5:22

    Go routines and channels are an easy way to maximize your program's efficiency.

You need to sign up for Treehouse in order to download course files.

Sign up