Cute Gopthers burning old c books concurrently – Source Rob Pike

With todays multicore processors writing concurrent code is very beneficial and the designers of Golang have made the concurrency model in Golang extremely easy and simple  to implement in your code, as we will now see in the example below.

Just a note on the above mention of multicore CPU’s. Just because the system has more than 1 core and you write concurrent code it does not necessarily  mean  it will run across more than one core. To see why this is and to also understand why ‘Concurrency Is Not Parallelism’ you should watch Rob Pikes talk here. Heck even if you don’t plan on programming Go you should probably watch it anyway.

Example

 Code analysis

Calling a function concurrently is really simple. We just use the ‘go’ keyword before the call

However usually we when we have multiple things happening concurrently we want to make sure that the individual processes synchronize  together at some point in the programs execution.

For example in a web page backed by a database, we might want to make multiple database queries concurrently, but we need to wait until they have all returned their datasets before we render the data in HTML and send the page over the wire to the user.

Fortunately this is quite easy using the Sync package

First we define how many go routines we will be waiting for until we release the block

Then at the end of our concurrent go routine we need to tell sync that we have completed one of the tasks, which will decrement the waiting counter.

Finally we need to tell the program where to block. The code after the call to wait() will not execute until all go routines have finished their tasks by them indicating so – by calling done()

If you run this example, you will see that each call to the go routined function in main() get’s called and then moves on to the next goroutine call. Rather than sequentially calling goroutine A then goroutine B and goroutine C the function calls happen concurrently.

This is show by waiting in our goroutine for 3 seconds. Once the program executes it waits 3 seconds then all our called go routines will print their output together. If we didn’t use concurrency the program would wait 3 secs then print its first output, then wait another 3 seconds (6 seconds in total) and then print its output and finally wait again and finally finish after 9 seconds.

You might also notice that we can use call go routines on an anonymous function / closure. This is another of Go’s awesome features (first class functions).

Note: This is not the only way to sync in Go. For a post on channels vs the above method please read – channels-vs-sync-package. I personally find the sync package cleaner

Conclusion

Go makes concurrency both clean and simple. Abstracting away all the complexities which other languages don’t. Because of this, there is no reason in this day and age you should not be writing concurrent code where you can