# Concurrency

## Goroutines

* Goroutine is a function that runs independently of the function that started it
* Goroutine can be any function that's called after special keyword `go`
* Frequently used to run function in the "background" while the main part does something else

## Channels

* Pipeline for sending and receiving data
* Channels allows one goroutine to send structured data to another goroutine
* Channels can be used to block the main goroutine until all other goroutines finish their execution
* Like network socket, they can be unidirectional or bidirectional
* Can be short-live or long-lived
* Declared with the keyword `chan` along with a data type
* Default value of a channel is `nil`, so value needs to be assigned
  * Value can be assigned with the `make` function
* Writing and reading from channel is done with arrow syntax, where the arrow points the direction
* Sending and reading are blocking operations, meaning
  * when data is sent to channel using a goroutine, it will be blocked until data is consumed by another goroutine
  * when receiving data from channel using goroutine, it will be blocked until the data is available in the channel
* To avoid deadlocks, sender can close a channel. This means channel can't be communicated over
* Buffered channels can be used to create channels which don't block until channel capacity is exceeded
  * For example: `make(chan int, 100)`

## Waitgroups

* Waitgroup allows to block a specific code block to allow a set of of goroutines to complete execution
* The following are the main methods of waitgroups
  * `add` - waitgroup act as counter holding the number of goroutines or functions to wait for. When counter is 0. the waitgroup releases the goroutines
  * `wait` - blocks the execution of the application until the waitgroup counter becomes 0
  * `done` - decreases the waitgroup counter by a value of 1

## References

* <https://blog.knoldus.com/achieving-concurrency-in-go/>
* <https://www.scaler.com/topics/golang/waitgroup-in-golang/>