Gain insights into implementing concurrency in Go, explore common patterns, and learn to write efficient, practical applications leveraging Go's outstanding support for concurrency.

Go.tar.gz

DataRaceBuilder

temp

Mastering concurrency can make you a much more in-demand developer on the job market. It's becoming an increasingly important concept in modern programming as multi-core devices become more and more prevalent.

The good news is that Go has some outstanding support for concurrency out of the box that makes implementation a breeze. In fact, concurrency in Go is easier to implement and faster than in any other major language.

In this course, you'll start off with a general introduction to concurrency and build up to more advanced concepts and implementation in Go. You'll also have a chance to go through some common patterns that will make your life easier and your code more efficient. By the time you're done, you'll be able to make use of Go to write efficient, practical applications that use concurrency.

Mastering Concurrency in Go

package main
import "fmt"

func SumOfSquares(c, quit chan int) {
  y := 1
  for {
    select {
    case c <- (y*y):
      y++
    case <-quit:
      return
    }
  }
}

func main() {
  mychannel := make(chan int)
  quitchannel:= make(chan int)
  sum:= 0
  go func() {
    for i := 1; i <= 5; i++ {
      sum += <-mychannel
    }
    fmt.Println(sum)
    quitchannel <- 0
  }()
  SumOfSquares(mychannel, quitchannel)
}

Let's go over the changes we made to the `SumofSquares` function.

```
func SumOfSquares(c, quit chan int) {
  y := 1
  for {
    select {
    case c <- (y*y):
      y++
    case <-quit:
      return
    }
  }
}
```

First of all, we declare a variable `y` and then jump to the `For-Select` Loop. We have two cases in our select statements: 

1. ` case c <- (y*y):`
This is to send the square of `y` over the channel `c` which is being received in the goroutine created in the main routine. 

2.  `case <-quit:` This is to receive a message from the main routine which, when received, will return from the function. 


  
This wasn't that hard, right? I accept that there can be numerous other approaches to solve the `SumOfSquares` function but I wanted you to practice with the `select` statement. I hope you had fun and let's meet again in the next lesson! 

Let's go over the solution of the Sum of Squares problem using `select` statements. 

Introduction to Concurrency

Building Blocks of Concurrency in Go

Exam I on Mastering Concurrency in Go

Basic Concurrency Patterns in Go

Exam II on Mastering Concurrency in Go

Solution Review: Sum of Squares