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

The for-select loop can be structured as follows:

for { //either range over a channel or loop infinitely
  select {
    //handle channel operations
  }
}

First, let's try to loop over something that goes on infinitely. 

package main
import "fmt"
func getNews(newsChannel chan string){
  NewsArray := [] string {"Roger Federer wins the Wimbledon","Space Exploration has reached new heights","Wandering cat prevents playground accident"}
  for _, news := range NewsArray{
    newsChannel <- news 
  }

  newsChannel <- "Done"
  close(newsChannel)

}

func main() {
  myNewsChannel := make(chan string)

  go getNews(myNewsChannel)
  
  for {
    select{
      case news := <-myNewsChannel:
        fmt.Println(news)
        if news == "Done"{
          return
        }
      default:
    }
    
  }
}

You might have wondered why the loop did not run infinitely. Well, that’s because I checked for my `"Done"` signal and returned from the main routine in **lines 23-25** as to prevent an infinite loop from running. 

Now the for-loop below enables us to execute the select statement infinitely. This is pretty handy in situations where we have to keep taking inputs from different channels.

```
for {
    select{
      case news := <-myNewsChannel:
        fmt.Println(news)
        if news == "Done" {
          return
        }
      default:
    
    }
    
  }
```

In the code above, I just have three headlines but obviously, the headlines never stop and you want to keep looking for them. 


Let's look at another situation:


Let's see how we can combine the `for` and `select` statements in order to communicate over channels in Go.


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

The For-Select Loop