Gain insights into Go's concurrency, delve into efficient programming techniques, learn advanced concepts, and discover how to enhance performance and robustness in your applications.

TarballFiber.tar.gz

raceFlag

server side

user input

server side-copy

serverJob

Go (also known as Golang) is one of the most popular languages today and is a key part of many enterprise tech stacks. Because Go's memory management architecture makes concurrency easier, many developers prefer it over traditional languages.

In this course, you will learn the core constructs and techniques of Go as well as advanced concepts of the language. In particular, you’ll learn how to program efficiently by becoming aware of the pitfalls and patterns that are commonly encountered in Go and by building your own applications.

Once you’ve completed this course, you will be able to write concurrent programs and improve the performance of existing ones, thus creating a more robust experience for everyone. Concurrency is in high demand today since it enables developers to reduce execution time of applications significantly, and Golang provides a very rich support for achieving this.

Concurrency in Go

# Problem breakdown

Let’s walk through the challenge step by step. Livelock occurs when multiple processes constantly try to resolve an issue by backtracking, reverting, retrying, or rolling back. As per the problem statement, both spouses are overly courteous, and if the other spouse is hungry, they will pass over the spoon. Only two goroutines are involved.


# Code walkthrough

Let’s walk through the code.


package main

import (
	"fmt"
	"sync"
	"time"
	"runtime"
)

func main() {
	runtime.GOMAXPROCS(4)
	type value struct {
		sync.Mutex
		id     string
		value1 string
		value2 string
		locked bool
	}

	lock := func(v *value) {
		v.Lock()
		v.locked = true
	}

	unlock := func(v *value) {
		v.Unlock()
		v.locked = false
	}

	move := func(wg *sync.WaitGroup, v1, v2 *value) {
		defer wg.Done()
		for i := 0; ; i++ {
			if i >= 3 {
				fmt.Println("canceling goroutine...")
				return
			}

			fmt.Printf("%v: %v \n", v1.id, v1.value1)
			lock(v1) // <1>

			time.Sleep(2 * time.Second)
			fmt.Printf("%v: Checking if %v \n", v1.id, v2.value2)
			if v2.locked { // <2>
				fmt.Printf("%v: Leaving spoon \n", v1.id)
				unlock(v1) // <3>
				continue
			}
		}
	}

	a, b := value{
		id: "Alice", 
		value1: "I am picking up spoon",
		value2: "Alice is hungry", 
	}, value{
		id: "Bob", 
		value1: "I am picking up spoon",
		value2: "Bob is hungry",
	}
	
	var wg sync.WaitGroup
	wg.Add(2)
	go move(&wg, &a, &b)
	go move(&wg, &b, &a)
	// go move(&wg, &a, &b)
	// go move(&wg, &a, &b)
	wg.Wait()
}


When we run the code and observe the output, we see that both Alice and Bob are hungry. The moment either one of them tries to pick up the spoon, they check whether the other spouse is hungry or not. Since the spouse is also hungry, they will leave the spoon. Both of them do the same thing, and no one can eat.


# Explanation

First, let’s understand the functions of the `lock` and `unlock`. The `lock` and `unlock` functions are the anonymous functions we use on the locking mechanism. We use both functions to pass the pointer reference of the resource, which creates and releases the lock. To keep track of this, we use the `struct` function.

We have one more anonymous function, `move`, which has an infinite loop that demonstrates livelock. The first process (`Alice`) acquires the lock on resource `x` (the `spoon`). Before using the resource, `Alice` checks if the second process (`Bob`) requires the resource based on whether `Bob` is hungry or not. If `Bob` requires the resource, `Alice` will release the lock on the `spoon`.

The important lines in the code are as follows:

- **Line 39:** The first process (`Alice`) acquires the resource (`spoon`).
- **Line 41:** The CPU goes to another goroutine for execution.
- **Line 43:** We check if the other process requires the resources (if Bob is hungry).
- **Line 45:** The first process releases the lock on the acquired resource (the `spoon`).

The reason for livelock in this case is the delay provided by the `Sleep` function. If we’re executing some heavy computational function, instead of sitting idle, preemption will happen to avoid starvation. The compiler will work on another goroutine and start its execution.

We use `WaitGroup` to tell the `main` goroutine to stop until all the goroutines complete their execution.


Check the solution to the challenge of writing code with a livelock condition.


Solution: Write Code with Livelock

Check the solution to the challenge of writing code with a livelock condition.

Introduction to Concurrency

General Concepts

Sync

Goroutines

Channels

Implementing Concurrency Patterns

Conclusion

Solution: Write Code with Livelock

Problem breakdown