Concurrency

Jun 10, 2023

What is concurrency

Concurrency is the ability of a system or program to have multiple tasks in progress at the same time. It is a way of designing and organizing a system to allow multiple tasks to overlap in their execution, rather than executing them sequentially one after the other.

Concurrency is often used in the context of computer programming, where it allows multiple tasks to be performed concurrently within a single program. It can be used to improve the performance and responsiveness of a program by allowing it to perform multiple tasks at the same time, rather than executing them one at a time in a sequential manner.

There are several different ways to implement concurrency in a program, including:

Multi threading: This involves dividing a program into multiple threads of execution that can run concurrently on separate cores or processors.
Asynchronous programming: This involves using asynchronous functions or methods that allow a program to perform multiple tasks concurrently, without blocking the execution of the program.
Event-driven programming: This involves using a programming model in which the program responds to events or triggers, allowing it to perform multiple tasks concurrently in response to different events.

Concurrency can be useful in a variety of contexts, including improving the performance and responsiveness of programs that perform multiple tasks, or that need to interact with external systems or resources. However, it can also introduce complexity and the need for careful design and testing in order to avoid race conditions and other issues that can arise when multiple tasks are running concurrently.

How concurrency achieved in golang

In Go, concurrency is achieved through the use of goroutines and channels.

A goroutine is a lightweight concurrent function execution.

Goroutines are created using the go keyword, followed by a function call.

When a goroutine is created, it is scheduled to run concurrently with the calling function.

Channels are a way to communicate between goroutines.

They are used to send and receive values between goroutines.

Channels can be created using the make function,

and values can be sent and received using the <- operator.

Here is an example of how to use goroutines and channels in Go:

package main

import "fmt"

func main() {
	// Create a channel of type int
	c := make(chan int)
	// Launch a goroutine that sends the value 42 to the channel
	go func() {
		c <- 42
	}()
	// Receive the value from the channel and print it
	fmt.Println(<-c)
}

In this example, the main function creates a channel of type int and launches a goroutine that sends the value 42 to the channel.

The main function then receives the value from the channel and prints it.

Goroutines and channels are powerful tools for building concurrent programs in Go.

They allow developers to easily create and manage concurrent tasks, and communicate between them using channels.

Goroutines

Goroutines are functions or methods that run concurrently with other functions or methods.

Go routines are lightweight concurrent threads that can be used to perform tasks concurrently in Go.

Go routines are managed by the Go runtime, and can be created and scheduled using the go keyword.

Here is an example of how to create and use Go routines in Go:

package main

import (
	"fmt"
	"time"
)

func printNumbers(c chan int) {
	for i := 0; i < 10; i++ {
		c <- i
		time.Sleep(time.Millisecond * 100)
	}
	close(c)
}

func main() {
	c := make(chan int)
	go printNumbers(c)

	for i := range c {
		fmt.Println(i)
	}
}

In this example, the printNumbers function is a Go routine that sends a series of numbers to a channel c. The main function creates the channel and starts the Go routine using the go keyword. The main function then iterates over the channel, printing the numbers as they are received.

Go routines are useful for writing concurrent programs that can take advantage of multiple CPU cores or that need to perform multiple tasks simultaneously.

They are a key feature of Go’s concurrency model, and are used in many types of applications.

Overall, Goroutines are a powerful and flexible tool for writing concurrent programs in Go.

To communicate between Go routines, you can use a variety of techniques, including:

Channels: Channels are a built-in data structure in Go that allow Go routines to send and receive values of a specific type. You can use channels to synchronize Go routines,

pass data between them, or signal the completion of a task.
Shared variables: You can use shared variables to communicate between Go routines, but you need to use synchronization mechanisms such as mutexes to protect against race conditions.
Wait groups: Wait groups are a built-in data structure in Go that allow you to wait for a group of Go routines to finish. You can use wait groups to synchronize Go routines, or to signal the completion of a task.
Timers and Tickers: Timers and tickers are built-in data structures in Go that allow you to schedule tasks or send signals at regular intervals. You can use timers and tickers to synchronize Go routines or to trigger actions based on time.

Overall, there are many ways to communicate between Go routines in Go, and the appropriate method depends on the specific requirements of your application.

Channels

In Go, a channel is a communication mechanism that allows one goroutine to send values to another goroutine.

Channels are a key feature of Go’s concurrency model, and are used to coordinate the execution of multiple goroutines.

Channels have a type, which specifies the type of values that can be sent over the channel.

To create a channel, you use the make function with the chan keyword, like this:

ch := make(chan int)

This creates a channel that can be used to send and receive int values.

To send a value over a channel, you use the <- operator, like this:

ch <-5

This sends the value 5 over the channel. The goroutine that sent the value will block until another goroutine is ready to receive the value.

To receive a value from a channel, you use the same <- operator, like this:

value := <-ch

This receives a value from the channel and assigns it to the variable value.

The receiving goroutine will block until a value is available to be received.

Here is an example of using a channel to send values between two goroutines:

func main() {
    ch := make(chan int)

    go func() {
        ch <- 5
    }()

    value := <-ch
    fmt.Println(value) // Output: 5
}

Types of channels and use

In Go, a channel can be either buffered or unbuffered.

A buffered channel has a fixed-size buffer that stores values that are sent over the channel.

An unbuffered channel does not have a buffer, and values are sent directly from the sender to the receiver.

The main difference between buffered and unbuffered channels is how they handle the communication between goroutines. With a buffered channel, a goroutine can send a value over the channel without blocking, as long as there is space in the buffer. The receiver can then receive the value at a later time, when it is ready. This allows goroutines to communicate asynchronously, without having to wait for each other.

On the other hand, an unbuffered channel does not have a buffer, so the sender must wait for the receiver to be ready to receive the value before the value can be sent. This means that the communication between goroutines is synchronous, and the sender must wait for the receiver to receive the value before it can continue execution.

Here is an example of using a buffered channel:

ch := make(chan int, 2) // Create a buffered channel with a capacity of 2

ch <- 1 // Send value without blocking
ch <- 2 // Send value without blocking

fmt.Println(<-ch) // Receive value
fmt.Println(<-ch) // Receive value

In this example, the buffered channel has a capacity of 2, so the first two sends do not block.

The receiver can then receive the two values at a later time.

Here is an example of using an unbuffered channel:

ch := make(chan int) // Create an unbuffered channel

go func() {
    ch <- 1 // Send value
}()

fmt.Println(<-ch) // Receive value

In this example, the unbuffered channel does not have a buffer, so the send operation blocks until the value is received by the receiver.

Whether to use a buffered or unbuffered channel depends on the needs of your program.

Buffered channels can be useful for improving the performance of concurrent programs by allowing goroutines to communicate asynchronously, but they can also lead to complex behavior if not used carefully. Unbuffered channels are simpler to use, but can result in slower communication between goroutines.

When to use

Buffered channels can be useful in cases where you want to allow goroutines to communicate asynchronously, without having to wait for each other. This can be useful for improving the performance of concurrent programs, especially when the communication between goroutines is frequent or high-volume.

On the other hand, unbuffered channels are simpler to use and can be easier to reason about, as they provide a more direct form of communication between goroutines. They can also be useful in cases where you want to ensure that the communication between goroutines is synchronous, or when the volume of communication is low.