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

Fan-In refers to a technique in which you join data from multiple inputs into a single entity. On the other hand, Fan-Out means to divide the data from a single source into multiple smaller chunks. In this lesson, we'll learn how to make use of both these techniques. 

The code below is from the previous [lesson](https://www.educative.io/collection/page/6374943524651008/6542449973395456/5156799218974720) where two receiving operations were blocking each other.

```
	fmt.Println(<-positionChannel1)
	fmt.Println(<-positionChannel2)
```

These operations were taking turns not only in printing value on to the console but also in proceeding to the next computation. 

Check it out below:

package main

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

func updatePosition(name string) <-chan string { 
	positionChannel := make(chan string)

	go func() {
		for i := 0; ; i++ {
			positionChannel <- fmt.Sprintf("%s %d", name , i)
			time.Sleep(time.Duration(rand.Intn(1e3)) * time.Millisecond)
		}
	}()

	return positionChannel
}

func main() {
	positionChannel1 := updatePosition("Legolas :") 
	positionChannel2 := updatePosition("Gandalf :")
	

	for i := 0; i < 5; i++ {
		fmt.Println(<-positionChannel1)
		fmt.Println(<-positionChannel2)
	}

	fmt.Println("Done with getting updates on positions.")
}


But what if you want to get position updates as soon as they are updated? This is where the fan-in technique comes into play. By using this technique, we'll combine the inputs from both channels and send them through a single channel. Look at the code below to see how it's done:



package main

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

func updatePosition(name string) <-chan string { 
	positionChannel := make(chan string)

	go func() {
		for i := 0; ; i++ {
			positionChannel <- fmt.Sprintf("%s %d", name , i)
			time.Sleep(time.Duration(rand.Intn(1e3)) * time.Millisecond)
		}
	}()

	return positionChannel
}

func fanIn(mychannel1, mychannel2 <-chan string) <-chan string {
	mychannel := make(chan string) 

	go func() { 
		for {
			mychannel <- <-mychannel1 
		}
	}()

	go func() { 
		for {
			mychannel <- <-mychannel2
		}
	}()

	return mychannel
}


func main() {
	positionsChannel := fanIn(updatePosition("Legolas :"), updatePosition("Gandalf :"))
	

	for i := 0; i < 10; i++ {
		fmt.Println(<-positionsChannel)
	}

	fmt.Println("Done with getting updates on positions.")
}





The crux of our technique lies in the `fanIn` function:

```
func fanIn(mychannel1, mychannel2 <-chan string) <-chan string {
	mychannel := make(chan string) 
	
	go func() { 
		for {
			mychannel <- <-mychannel1 
		}
	}()

	go func() { 
		for {
			mychannel <- <-mychannel2 
		}
	}()

	return mychannel
}
```

Here we take in two channels as input and specify one channel as the return argument, i.e., `mychannel` which is the Fan-In channel. Afterward, we declare two goroutines from **line 23** to **line 33** which receive data from `mychannel1` and `mychannel2` and send it to our Fan-In channel, `mychannel` on **line 25** and on **line 31**. Hence, data will be passed to `mychannel` as soon as it is received by `mychannel1` and `mychannel2` because the goroutines are running concurrently. 
 
Additionally, we pass the `updatePosition` function for both Legolas and Gandalf into our `fanIn` function on **line 40**. The rest of the logic is the same as before. The only difference comes from the fact that `mychannel1` and `mychannel2` are communicating with `mychannel` now instead of directly communicating with the main routine as before. You will realize from the output that the position updates are no longer sequential. Thus, by using this technique, we can solve the blocking issue that we were previously facing. 

Let's jump to the Fan-Out technique now. The code below generates an array of random numbers and prints all the values after doubling them.

In this lesson, we will get familiar with Fan-In, Fan-Out techniques which are used to multiplex and demultiplex data 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

Fan-In, Fan-Out