finish with mutex exercises

Author: steevehook

mutexes/exercises/1/solution/solution.go

@@ -16,6 +16,14 @@ import (
 
 // run the tests using:
 // GOFLAGS="-count=1" go test -race .
+
+// SOLUTION
+// The problem with this code is it has both:
+// a deadlock and a race condition.
+// The deadlock happens because we accidentally
+// forget to call Unlock().
+// The race condition happens because
+// we mix and match Atomics with Mutexes
 func main() {
 	clicks := exercise()
 	fmt.Println("total clicks:", clicks.total)

mutexes/exercises/2/exercise.go

@@ -42,7 +42,7 @@ func exercise(c *catalog, ids ...string) {
 				c.get(id)
 			}
 			c.add("generated_"+strconv.Itoa(i), "generated product")
-		}(i+1)
+		}(i + 1)
 	}
 
 	wg.Wait()
@@ -57,15 +57,15 @@ func (c *catalog) add(id, product string) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 	// simulate load
-	time.Sleep(500*time.Nanosecond)
+	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)
+	time.Sleep(500 * time.Nanosecond)
 	// avoid key existence check
 	return c.data[id]
 }

mutexes/exercises/2/solution/solution.go

@@ -17,6 +17,12 @@ import (
 
 // run the tests using:
 // GOFLAGS="-count=1" go test .
+
+// SOLUTION
+// The problem with this code is mainly because,
+// we are using a regular Mutex, thus slowing down
+// all the read operations. Using a RWMutex instead
+// will give the same results at an improved speed
 func main() {
 	c := &catalog{data: map[string]string{
 		"p1": "apples",
@@ -42,7 +48,7 @@ func exercise(c *catalog, ids ...string) {
 				c.get(id)
 			}
 			c.add("generated_"+strconv.Itoa(i), "generated product")
-		}(i+1)
+		}(i + 1)
 	}
 
 	wg.Wait()
@@ -57,15 +63,15 @@ func (c *catalog) add(id, product string) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 	// simulate load
-	time.Sleep(500*time.Nanosecond)
+	time.Sleep(500 * time.Nanosecond)
 	c.data[id] = product
 }
 
 func (c *catalog) get(id string) string {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
 	// simulate load
-	time.Sleep(500*time.Nanosecond)
+	time.Sleep(500 * time.Nanosecond)
 	// avoid key existence check
 	return c.data[id]
 }

mutexes/exercises/3/solution/solution.go

@@ -17,6 +17,11 @@ import (
 // run the tests using:
 // GOFLAGS="-count=1" go test .
 
+// SOLUTION
+// The problem with this implementation is the fine-grained
+// defined context by the mutex, resulting in an undesired result.
+// All we really need to fix the problem is limit the context
+// of the mutex, which will also give us the expected result
 func main() {
 	now := time.Now()
 	count := exercise()
@@ -37,7 +42,7 @@ func exercise() int {
 			mu.Lock()
 			a = A
 			b = B
-			count += a+b
+			count += a + b
 			A++
 			B++
 			mu.Unlock()

mutexes/exercises/4/exercise.go

@@ -50,7 +50,7 @@ func exercise() int {
 			defer wg.Done()
 			muA.Lock()
 			defer muA.Unlock()
-			A+=5
+			A += 5
 		}()
 	}
 

mutexes/exercises/4/solution/solution.go

@@ -17,6 +17,14 @@ import (
 // run the tests using:
 // GOFLAGS="-count=1" go test .
 
+// SOLUTION
+// The problem with this code that uses 2 mutexes is the fact
+// That the second mutex depends on the use of the first mutex,
+// thus creating a perfect environment for lock contention.
+// Since operations on A and B are independent, solving this is
+// easy, all we have to do is release the mutex on A ASAP,
+// thus allowing the other go routine to use it immediately
+// and as a result the whole program executes faster
 func main() {
 	now := time.Now()
 	A := exercise()
@@ -50,7 +58,7 @@ func exercise() int {
 			defer wg.Done()
 			muA.Lock()
 			defer muA.Unlock()
-			A+=5
+			A += 5
 		}()
 	}
 

mutexes/exercises/5/exercise.go

@@ -19,6 +19,7 @@ import (
 // GOFLAGS="-count=1" go test .
 
 func main() {
+	// p1 and p2 are the number of executions per process
 	p1, p2 := exercise(time.Second)
 	fmt.Println("p1:", p1)
 	fmt.Println("p2:", p2)

mutexes/exercises/5/solution/solution.go

@@ -18,6 +18,15 @@ import (
 // run the tests using:
 // GOFLAGS="-count=1" go test .
 
+// SOLUTION
+// The problem we're solving here is Starvation.
+// Even if all operations are equal in terms of time burst.
+// Because we have 3 calls to read and 1 call to write,
+// the mutex local to each call is being used more frequently,
+// thus allowing one process to acquire it way more often than the other.
+// The fix simply using the mutex evenly distributing it across workers/Gs.
+// In other words, just use the mutex directly, not inside the read call.
+// Always be careful with mutexes local to the methods and test for starvation.
 func main() {
 	p1, p2 := exercise(time.Second)
 	fmt.Println("p1:", p1)

mutexes/exercises/6/exercise.go

@@ -10,6 +10,7 @@ import (
 // Find what's wrong in the exercise() function
 // Make sure all the tests are passing
 // DO NOT remove any Sleep() calls
+// DO NOT remove any steps, i.e: transfer, check, revert
 
 // try running this with the -race flag
 // go run -race exercise.go
@@ -18,24 +19,34 @@ import (
 // GOFLAGS="-count=1" go test .
 
 func main() {
-	exercise()
+	now := time.Now()
+	accounts := exercise()
+	for _, a := range accounts {
+		fmt.Printf("'%s' amount: $%v\n", a.id, a.amount)
+		fmt.Printf("'%s' transactions: %v\n", a.id, a.transactions)
+	}
+	fmt.Println("elapsed:", time.Since(now))
 }
 
-func exercise() {
+func exercise() []*account {
 	var mu sync.Mutex
-	var n1, n2 int
-	f1, f2 := file{mu: &mu, name: "f1"}, file{mu: &mu, name: "f2"}
-	//write := func(f *file, name1, name2 string) {
-	//	for i := 0; i < 5; i++ {
-	//		if  f.write([]byte(name1)) || f.write([]byte(name2)) {
-	//			return
-	//		}
-	//	}
-	//}
-	write := func(f *file, n1, n2 *int) {
+	accounts := []*account{
+		{id: "a1", amount: 5},
+		{id: "a2", amount: 10},
+	}
+	b1 := bank{mu: &mu, name: "bank1"}
+	b2 := bank{mu: &mu, name: "bank2"}
+	write := func(b *bank, amount float64, accounts ...*account) {
 		for i := 0; i < 5; i++ {
-			if  f.write(n1) || f.write(n2) {
-				fmt.Println(f.name, "successfully wrote to file")
+			ok := true
+			for _, a := range accounts {
+				if !b.transfer(a, amount) {
+					ok = false
+					break
+				}
+			}
+			if ok {
+				fmt.Printf("'%s' successfully transferred: $%v\n", b.name, amount)
 				return
 			}
 		}
@@ -45,48 +56,55 @@ func exercise() {
 	wg.Add(2)
 	go func() {
 		defer wg.Done()
-		write(&f1, &n1, &n2)
+		// transfer $200 from bank1 to all accounts
+		write(&b1, 200, accounts...)
 	}()
 	go func() {
 		defer wg.Done()
-		write(&f2, &n1, &n2)
+		// transfer $100 from bank2 to all accounts
+		write(&b2, 100, accounts...)
 	}()
 
 	wg.Wait()
-	fmt.Println(n1)
-	fmt.Println(n2)
+	return accounts
 }
 
-type file struct {
+type account struct {
+	id           string
+	amount       float64
+	transactions []string
+}
+
+type bank struct {
 	name string
 	mu   *sync.Mutex
-	//data []byte
 }
 
-//func (f *file) write(data []byte) bool {
-func (f *file) write(n *int) bool {
-	fmt.Println(f.name, "trying to write", *n)
-	f.mu.Lock()
-	//f.data = data
-	*n += 1
-	f.mu.Unlock()
+func (b *bank) transfer(acc *account, amount float64) bool {
+	// transfer the money
+	fmt.Printf("'%s' trying to transfer: $%v to '%s'\n", b.name, amount, acc.id)
+	b.mu.Lock()
+	acc.amount += amount
+	b.mu.Unlock()
 	time.Sleep(500 * time.Millisecond)
 
-	f.mu.Lock()
-	//if bytes.Equal(f.data, data) {
-	if *n == 1 {
-		f.mu.Unlock()
+	// check if the money were transferred
+	b.mu.Lock()
+	// if current balance equals to previous account balance
+	if acc.amount == acc.amount-amount {
+		b.mu.Unlock()
+		tx := fmt.Sprintf("%s: $%v", b.name, amount)
+		acc.transactions = append(acc.transactions, tx)
 		return true
 	}
-	f.mu.Unlock()
-
+	b.mu.Unlock()
 
 	time.Sleep(100 * time.Millisecond)
 
-	f.mu.Lock()
-	//f.data = nil
-	*n -= 1
-	f.mu.Unlock()
+	// revert the transfer
+	b.mu.Lock()
+	acc.amount -= amount
+	b.mu.Unlock()
 	time.Sleep(500 * time.Millisecond)
 	return false
 }

mutexes/exercises/6/exercise_test.go

@@ -2,8 +2,28 @@ package main
 
 import (
 	"testing"
+	"time"
 )
 
 // GOFLAGS="-count=1" go test .
 func TestExercise(t *testing.T) {
+	now := time.Now()
+	accounts := exercise()
+	elapsed := time.Since(now)
+	expectedAccounts := []account{
+		{id: "a1", amount: 305, transactions: []string{"bank2: $100", "bank1: $200"}},
+		{id: "a2", amount: 310, transactions: []string{"bank2: $100", "bank1: $200"}},
+	}
+
+	if len(accounts) != 2 {
+		t.Fatalf("expected number of account to be 2, got %d", len(accounts))
+	}
+	for i, a := range accounts {
+		if a.id != expectedAccounts[i].id || a.amount != expectedAccounts[i].amount || len(accounts[i].transactions) != 2 {
+			t.Fatalf("expected account to be %v, got %v", expectedAccounts[i], a)
+		}
+	}
+	if elapsed > 3*time.Second {
+		t.Fatalf("exercise took too long: %v", elapsed)
+	}
 }