go-concurrency

Aims to learn the knowledge about concurrency in Go

Flow control with channels

1. We can imagine that channel is a pipe, chan<- means to send a value into the channel. <-chan means to receive a value from the channel.

2. select ... case can execute sending value into a channel

Range and Close

1. A sender can close a channel to indicate that no more values will be sent.
2. Receivers can test whether a channel has been closed by assigning a second parameter to the receive expression. v, ok := <-ch, ok is false if there are no more values to receive and the channel is closed.
3. The loop for i:= range c receives values from the channel repeatedly until it is closed.
4. Only the sender should close a channel, never the receiver. Sending on a closed channel will cause a panic.
5. Channels aren't like files; you don't usually need to close them. Closing is only necessary when the receiver must be told there are no more values coming, such as to terminate a range loop.

Select

1. The select statement lets a goroutine wait on multiple communication operations
2. A select blocks until one of its cases can run, then it executes that case. It chooses one at random if multiple are ready

Default selection

1. The default case in a select is run if no other case is ready.
2. Use a default case to try a send or receive without blocking

select {
    case i:= <-c:
        // use i
    default: 
        // receive when c is blocked        
}

sync.Mutex

Channels are great for communication, but what if we don't need communication?

What if we just want to make sure only one goroutine can access a variable at a time to avoid conflicts? This concept is called mutual exclusion, and the conventional name for the data structure that provides it is mutex

Go's standard library provides mutual exclusion with sync.Mutex and its two methods: Lock and Unlock

sync.WaitGroup

https://tutorialedge.net/golang/go-waitgroup-tutorial/