add more mutexes exercises

Author: steevehook

mutexes/README.md

@@ -134,5 +134,6 @@ the database consistency which otherwise is not possible for a non-serial schedu
 - [raceacquire - Go Source Code](https://github.com/golang/go/blob/master/src/runtime/race.go#L515)
 - [racecall - Go Source Code](https://github.com/golang/go/blob/master/src/runtime/race.go#L348)
 - [racecall - GOASM Source Code](https://github.com/golang/go/blob/master/src/runtime/race_amd64.s#L384)
+- [RWMutex - Go Source Code](https://github.com/golang/go/blob/master/src/sync/rwmutex.go#L28)
 
 [Home](https://github.com/golang-basics/concurrency)

mutexes/atomic-mutex-mix/main.go

@@ -0,0 +1,34 @@
+package main
+
+import (
+	"fmt"
+	"sync"
+	"sync/atomic"
+)
+
+// try running this with the -race flag
+// go run -race main.go
+func main() {
+	var count int32
+	var mu sync.Mutex
+	var wg sync.WaitGroup
+
+	for i := 0; i < 10000; i++ {
+		wg.Add(2)
+		go func() {
+			defer wg.Done()
+			atomic.AddInt32(&count, 1)
+		}()
+		go func() {
+			defer wg.Done()
+			mu.Lock()
+			count++
+			mu.Unlock()
+		}()
+	}
+
+	wg.Wait()
+	// the result is correct, but Go is not able to properly detect a race condition
+	// due to mixed usage of Mutex and Atomics
+	fmt.Println("count:", count)
+}

mutexes/deadlock-and-race/main.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"fmt"
+	"sync"
+)
+
+// Having both deadlock and race
+// will result in the program hanging
+// when ran with -race flag
+// go run -race main.go => will show races, but hang forever
+
+// Try running the program first without -race => fix the deadlock
+// go run main.go
+// then using the -race flag => fix the race condition
+// go run -race main.go
+func main() {
+	var count int
+	var mu sync.Mutex
+	var wg sync.WaitGroup
+
+	wg.Add(2)
+	go func() {
+		defer wg.Done()
+		count++
+
+	}()
+	go func() {
+		defer wg.Done()
+		count++
+	}()
+
+	wg.Wait()
+	mu.Lock()
+	mu.Lock()
+	fmt.Println("count:", count)
+}

mutexes/exercises/1/exercise.go

@@ -0,0 +1,76 @@
+package main
+
+import (
+	"fmt"
+	"sync"
+	"sync/atomic"
+)
+
+// EXERCISE:
+// Find what's wrong in the following code
+// Make sure all the tests are passing
+// Make sure there's no deadlock or race condition
+// Hint: Limit the go routines (100), then find and fix the deadlock first
+
+// try running this with the -race flag
+// go run -race exercise.go
+
+// run the tests using:
+// GOFLAGS="-count=1" go test -race .
+func main() {
+	clicks := exercise()
+	fmt.Println("total clicks:", clicks.total)
+}
+
+func exercise() clickCounter {
+	var mu sync.Mutex
+	var wg sync.WaitGroup
+	clicks := clickCounter{
+		mu: &mu,
+		elements: map[string]int{
+			"btn1": 0,
+			"btn2": 0,
+		},
+	}
+
+	for i := 0; i < 1000; i++ {
+		wg.Add(3)
+		go func() {
+			defer wg.Done()
+			if len(clicks.elements) > 10 {
+				fmt.Println("we got more than 10 elements")
+			}
+		}()
+		go func() {
+			defer wg.Done()
+			clicks.add("btn1")
+			clicks.add("btn2")
+		}()
+		go func() {
+			defer wg.Done()
+			total := atomic.LoadInt64(&clicks.total)
+			if total > 20 {
+				fmt.Println("something is wrong")
+			}
+		}()
+	}
+
+	wg.Wait()
+	return clicks
+}
+
+type clickCounter struct {
+	mu       *sync.Mutex
+	elements map[string]int
+	total    int64
+}
+
+func (c *clickCounter) add(element string) {
+	c.mu.Lock()
+	if c.elements[element]+1 > 10 {
+		return
+	}
+	c.elements[element]++
+	c.total++
+	c.mu.Unlock()
+}

mutexes/exercises/1/exercise_test.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"testing"
+)
+
+// GOFLAGS="-count=1" go test -race .
+func TestExercise(t *testing.T) {
+	clicks := exercise()
+
+	n1 := clicks.elements["btn1"]
+	n2 := clicks.elements["btn2"]
+	total := clicks.total
+
+	if n1 != 10 {
+		t.Fatalf("expected number of clicks for btn1: %d, got: %d", 10, n1)
+	}
+	if n2 != 10 {
+		t.Fatalf("expected number of clicks for btn2: %d, got: %d", 10, n2)
+	}
+	if total != 20 {
+		t.Fatalf("expected total to be: %d, got: %d", 20, total)
+	}
+}

mutexes/exercises/1/solution/solution.go

@@ -0,0 +1,78 @@
+package main
+
+import (
+	"fmt"
+	"sync"
+)
+
+// EXERCISE:
+// Find what's wrong in the following code
+// Make sure all the tests are passing
+// Make sure there's no deadlock or race condition
+// Hint: Limit the go routines (100), then find and fix the deadlock first
+
+// try running this with the -race flag
+// go run -race exercise.go
+
+// run the tests using:
+// GOFLAGS="-count=1" go test -race .
+func main() {
+	clicks := exercise()
+	fmt.Println("total clicks:", clicks.total)
+}
+
+func exercise() clickCounter {
+	var mu sync.Mutex
+	var wg sync.WaitGroup
+	clicks := clickCounter{
+		mu: &mu,
+		elements: map[string]int{
+			"btn1": 0,
+			"btn2": 0,
+		},
+	}
+
+	for i := 0; i < 1000; i++ {
+		wg.Add(3)
+		go func() {
+			defer wg.Done()
+			clicks.mu.Lock()
+			defer clicks.mu.Unlock()
+			if len(clicks.elements) > 10 {
+				fmt.Println("we got more than 10 elements")
+			}
+		}()
+		go func() {
+			defer wg.Done()
+			clicks.add("btn1")
+			clicks.add("btn2")
+		}()
+		go func() {
+			defer wg.Done()
+			clicks.mu.Lock()
+			defer clicks.mu.Unlock()
+			if clicks.total > 20 {
+				fmt.Println("something is wrong")
+			}
+		}()
+	}
+
+	wg.Wait()
+	return clicks
+}
+
+type clickCounter struct {
+	mu       *sync.Mutex
+	elements map[string]int
+	total    int64
+}
+
+func (c *clickCounter) add(element string) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if c.elements[element]+1 > 10 {
+		return
+	}
+	c.elements[element]++
+	c.total++
+}

mutexes/exercises/2/exercise.go

@@ -0,0 +1,71 @@
+package main
+
+import (
+	"fmt"
+	"strconv"
+	"sync"
+	"time"
+)
+
+// EXERCISE:
+// Find what's wrong in the following code
+// Make sure all the tests are passing
+// DO NOT remove any Sleep() calls
+
+// try running this with the -race flag
+// go run -race exercise.go
+
+// run the tests using:
+// GOFLAGS="-count=1" go test .
+func main() {
+	c := &catalog{data: map[string]string{
+		"p1": "apples",
+		"p2": "oranges",
+		"p3": "grapes",
+		"p4": "pineapple",
+		"p5": "bananas",
+	}}
+
+	now := time.Now()
+	exercise(c, "p1", "p2", "p3", "p4", "p5")
+	fmt.Println("elapsed:", time.Since(now))
+}
+
+func exercise(c *catalog, ids ...string) {
+	var wg sync.WaitGroup
+	wg.Add(1000)
+
+	for i := 0; i < 1000; i++ {
+		go func(i int) {
+			defer wg.Done()
+			for _, id := range ids {
+				c.get(id)
+			}
+			c.add("generated_"+strconv.Itoa(i), "generated product")
+		}(i+1)
+	}
+
+	wg.Wait()
+}
+
+type catalog struct {
+	mu   sync.Mutex
+	data map[string]string
+}
+
+func (c *catalog) add(id, product string) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	// simulate load
+	time.Sleep(500*time.Nanosecond)
+	c.data[id] = product
+}
+
+func (c *catalog) get(id string) string {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	// simulate load
+	time.Sleep(500*time.Nanosecond)
+	// avoid key existence check
+	return c.data[id]
+}

mutexes/exercises/2/exercise_test.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"testing"
+	"time"
+)
+
+// GOFLAGS="-count=1" go test .
+func TestExercise(t *testing.T) {
+	c := &catalog{data: map[string]string{
+		"p1": "apples",
+		"p2": "oranges",
+		"p3": "grapes",
+		"p4": "pineapple",
+		"p5": "bananas",
+	}}
+
+	now := time.Now()
+	exercise(c, "p1", "p2", "p3", "p4", "p5")
+	elapsed := time.Since(now)
+	numberOfProducts := len(c.data)
+
+	if numberOfProducts != 1005 {
+		t.Fatalf("wrong number of products in the catalog, got: %d", numberOfProducts)
+	}
+	if elapsed > 10*time.Millisecond {
+		t.Fatalf("exercise took too long, elapsed: %v", elapsed)
+	}
+}