"Using PHP with MySQL" was retired on March 1, 2017. You are now viewing the recommended replacement.
Heads up! To view this whole video, sign in with your Courses account or enroll in your free 7-day trial. Sign In Enroll
Well done!
You have completed Go Language Overview!
You have completed Go Language Overview!
Preview
A "goroutine" is a simple way to make several function calls simultaneously. The work gets split up among all your CPU cores, and they all work on it at the same time.
- A goroutine is a simple way to make several function calls simultaneously. The work gets split up among your CPU cores, and they all work on it at the same time.
- A Go program starts with a single goroutine, which runs the
mainfunction
package main
import (
"fmt"
"time"
)
func longTask() {
fmt.Println("Starting long task")
time.Sleep(3 * time.Second)
fmt.Println("Long task finished")
}
func main() {
longTask()
longTask()
longTask()
}
- The first
longTaskcall runs, sleeps for 3 seconds, and then returns. Then the secondlongTaskcall runs, sleeps for 3 seconds, and so on. Because the calls tolongTaskrun one at a time, the program takes just over 9 seconds to complete. - Prepend the
gokeyword to a function call to launch another goroutine, which runs alongside the first.
go longTask()
go longTask()
go longTask()
- Now calls to
longTaskrun in separate goroutines. After each goroutine kicks off, it goes back to themaingoroutine and launches the next goroutine. - The problem is that as soon as the
maingoroutine finishes, the program exits. So the other goroutines don't get a chance to do anything. So just as a quick fix, we'll add a call toSleepto themainfunction:
go longTask()
go longTask()
go longTask()
time.Sleep(4 * time.Second)
More info
Related Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign upRelated Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign up
[MUSIC]
0:00
Say we have a function that averages
three seconds to complete, and
0:04
we need to run it three times.
0:08
If you made just one
function call at a time,
0:10
it would take around nine seconds,
but that's wasting computing power.
0:12
Your CPU probably has
multiple cores on it.
0:16
A simplified way to think of this
is like having several computers
0:19
inside your computer.
0:22
And if you're making just
one function call at a time,
0:24
only one of those
computers is getting used.
0:27
A go routine is a simple way to make
several function calls simultaneously.
0:30
The work gets split up
among those CPU cores.
0:34
And they all work on it at the same time.
0:37
So if your CPU has at least three cores
we can make our three function calls to
0:39
our three second function simultaneously,
0:44
meaning our program completes in
only three seconds instead of nine.
0:46
Go routines can help you even
if your CPU only has one core.
0:50
There are lots of tasks for which your
programs have to just sit around waiting,
0:54
like waiting for network connections.
0:57
Instead of waiting for
1:00
the connection to complete, your program
will be able to start several at once.
1:00
Then deal with each
connection as it's ready.
1:04
Go routines and
concurrency are deep topics, and
1:07
we're only going to skim the surface here.
1:09
Check the teacher's notes for
more info if you'd like to dive deeper.
1:12
Here we have a long task function
that simulates a task that takes
1:15
a long time to complete.
1:19
It does this by calling the Sleep
method from the time package,
1:20
which causes your program to pause for
a specified interval.
1:23
A go program starts with a single go
routine, which runs the main function.
1:27
In that go routine here in this program,
the first longTask call runs, sleeps for
1:31
three seconds and then returns, then
the second longTask call runs, sleeps for
1:36
three seconds and so on.
1:41
Because the calls to
longTask run one at a time,
1:42
the program takes just over
nine seconds to complete.
1:45
You can prepend the go keyword to
a function call to launch another go
1:48
routine, which runs alongside the first.
1:52
So let's prepend go to each of these calls
to longTask to run it as a go routine.
1:55
Then we'll run our program.
2:04
Now the calls to longTask
run in separate go routines.
2:06
After each go routine kicks off,
it goes back to the main go routine and
2:09
launches the next go routine.
2:13
But you can see that our program's
not producing any out put now.
2:15
The problem is that as soon as the main
go routine finishes, the program exits.
2:19
So the other go routines don't
get a chance to do anything.
2:23
So just as a quick fix, we'll add a call
to sleep to the main function as well.
2:26
So we'll say time.Sleep, and
we'll have this sleep for for seconds.
2:31
So 4 * time.Second.
2:37
We'll run this again.
2:42
And now while the main
go routine is sleeping,
2:44
the other go routines are able
to start and finish running.
2:47
Since they all start around the same time,
2:50
they all finish in just
over three seconds.
2:52
And the main go routine finishes
in just over four seconds.
2:54
Of course, in the real world
you won't know exactly how long
2:58
a go routine will take to complete.
3:01
So adding a call to sleep in
the main go routine isn't ideal.
3:03
It might sleep for too long or
it might not sleep for long enough.
3:06
Up next, we're going to look at channels.
3:09
Channels are a solution that let
you wait for a go routine and
3:11
give you a way to communicate
between go routines as well
3:15
You need to sign up for Treehouse in order to download course files.
Sign upYou need to sign up for Treehouse in order to set up Workspace
Sign up