add more examples + add 1 more slide in the mutexes presentation

Author: steevehook

mutexes/README.md

@@ -112,6 +112,7 @@ the database consistency which otherwise is not possible for a non-serial schedu
 - [Mutual Exclusion - Wiki](https://en.wikipedia.org/wiki/Mutual_exclusion)
 - [Dining Philosophers Problem - Wiki](https://en.wikipedia.org/wiki/Dining_philosophers_problem)
 - [Test and Set - Wiki](https://en.wikipedia.org/wiki/Test-and-set)
+- [Monitor - Wiki](https://en.wikipedia.org/wiki/Monitor_(synchronization))
 - [Tuple Space - Wiki](https://en.wikipedia.org/wiki/Tuple_space)
 - [Message Passing - Wiki](https://en.wikipedia.org/wiki/Message_passing)
 - [Semaphore - Wiki](https://en.wikipedia.org/wiki/Semaphore_(programming))
@@ -125,6 +126,12 @@ the database consistency which otherwise is not possible for a non-serial schedu
 - [Transaction Processing - Wiki](https://en.wikipedia.org/wiki/Transaction_processing)
 - [Pessimistic vs Optimistic Locking - StackOverflow](https://stackoverflow.com/questions/129329/optimistic-vs-pessimistic-locking)
 - [Pessimistic vs Optimistic Locking - StackOverflow Explanation](https://stackoverflow.com/a/58952004)
-- [Check Deadlock - Go Source Code](https://github.com/golang/go/blob/35ea62468bf7e3a79011c3ad713e847daa9a45a2/src/runtime/proc.go#L4159-L4233)
+- [Check Deadlock - Go Source Code](https://github.com/golang/go/blob/master/src/runtime/proc.go#L5122-L5221)
+- [Mutex.Lock() - Go Source Code](https://github.com/golang/go/blob/master/src/sync/mutex.go#L76)
+- [Mutex.lockSlow() - Go Source Code](https://github.com/golang/go/blob/master/src/sync/mutex.go#L108:17)
+- [RaceAcquire - Go Source Code](https://github.com/golang/go/blob/master/src/runtime/race.go#L37)
+- [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)
 
 [Home](https://github.com/golang-basics/concurrency)

mutexes/lock-contention/reduce-hold-time/main.go

@@ -1,49 +1,71 @@
 package main
 
 import (
+	"fmt"
 	"sync"
+	"time"
 )
 
-var mu sync.Mutex
-var c int
-
-func task1() {}
-func task2() {}
-func task3() {}
-func inc()   { c++ }
-
 func main() {
+	var mu sync.Mutex
 	var wg sync.WaitGroup
 	wg.Add(2)
+
 	go func() {
 		defer wg.Done()
-		work1()
+		now := time.Now()
+		// work: ~6s | acquire after: ~6s
+		// work1(&mu)
+		// work: ~6s | acquire after: ~1s
+		work2(&mu)
+		fmt.Println("work is done after:", time.Since(now))
 	}()
+
+	// simulate order of go routines
+	time.Sleep(100 * time.Nanosecond)
+
+	// other go routine that needs the same mutex
 	go func() {
 		defer wg.Done()
-		work2()
+		now := time.Now()
+		mu.Lock()
+		fmt.Println("acquired lock after:", time.Since(now))
+		mu.Unlock()
 	}()
+
 	wg.Wait()
 }
 
 // bad practice
-func work1() {
+func work1(mu *sync.Mutex) {
 	mu.Lock()
 	defer mu.Unlock()
 	task1()
-	inc()
-	task2() // I/O
+	task2()
 	task3()
 }
 
 // good practice
-func work2() {
-	task1()
+func work2(mu *sync.Mutex) {
+	// let's say only task 1 works with the CRITICAL SECTION
+	// every other task is just part of the work
 	func() {
 		mu.Lock()
 		defer mu.Unlock()
-		inc()
+		task1()
 	}()
-	task2() // I/O
+	task2()
 	task3()
 }
+
+func task1() {
+	time.Sleep(1 * time.Second)
+}
+
+func task2() {
+	time.Sleep(2 * time.Second)
+}
+
+func task3() {
+	time.Sleep(3 * time.Second)
+}

mutexes/mutex-implementation/mutex.c renamed to mutexes/mutex-implementation/main.c

@@ -33,14 +33,14 @@ void * pingpong(void * p) {
   } // for
 } // pingpong
 
-// gcc mutex.c -o exec
+// gcc main.c -o exec
 // ./exec
 int main() {
   setvbuf(stdout, NULL, _IONBF, 0);
-  pthread_t ping;
-  pthread_t pong;
-  pthread_create(&ping, NULL, pingpong, PING);
-  pthread_create(&pong, NULL, pingpong, PONG);
+  pthread_t ping_thread;
+  pthread_t pong_thread;
+  pthread_create(&ping_thread, NULL, pingpong, PING);
+  pthread_create(&pong_thread, NULL, pingpong, PONG);
   for(;;);
   return 0;
 }

mutexes/mutex-implementation/main.go

@@ -15,16 +15,18 @@ func main() {
 	var wg sync.WaitGroup
 
 	// if we increase the number of go routines
-	// this will quickly start to fail
-	// due to go routines status being awake
-	wg.Add(100)
-	for i := 0; i < 100; i++ {
-		go func(i int) {
+	// this could quickly be detected as a race condition
+	// due to too many go routines' status being awake
+	// Also there's no way we can control the go routines queue
+	// or have access to the runtime internals
+	wg.Add(1000)
+	for i := 0; i < 1000; i++ {
+		go func() {
 			defer wg.Done()
 			mu.Lock()
-			count = i
+			count++
 			mu.Unlock()
-		}(i)
+		}()
 	}
 	wg.Wait()
 
@@ -40,7 +42,6 @@ func (mu *mutex) Lock() {
 		return
 	}
 	for {
-		// continue
 		atomic.AddInt32(&mu.state, 1)
 		s := atomic.LoadInt32(&mu.state)
 		if s > 1 {
@@ -53,7 +54,7 @@ func (mu *mutex) Lock() {
 }
 
 func (mu *mutex) Unlock() {
-	if atomic.CompareAndSwapInt32(&mu.state, 1, 0) {
+	for atomic.CompareAndSwapInt32(&mu.state, 1, 0) {
 		return
 	}
 	panic("unlock of unlocked mutex")

mutexes/semaphore/main.go

@@ -1,9 +1,44 @@
 package main
 
+import (
+	"fmt"
+	"sync"
+	"sync/atomic"
+)
+
+var lock int32
+
+// try running this with the -race flag
+// go run -race main.go
 func main() {
-	// implement semaphore using atomics
-	// implement reentrant lock
-	//while (test_and_set(&lock) == 1);
-	//critical section  // only one process can be in this section at a time
-	//lock = 0;  // release lock when finished with the critical section
+	var count int
+	var wg sync.WaitGroup
+
+	// if we increase the number of go routines
+	// this could quickly be detected as a race condition
+	// due to too many go routines' status being awake
+	// Also there's no way we can control the go routines queue
+	// or have access to the runtime internals
+	wg.Add(1000)
+	for i := 0; i < 1000; i++ {
+		go func() {
+			defer wg.Done()
+			acquire()
+			count++
+			release()
+		}()
+	}
+
+	wg.Wait()
+	fmt.Println("count", count)
+}
+
+func acquire() {
+	for atomic.CompareAndSwapInt32(&lock, 0, 1) {
+	}
+}
+
+func release() {
+	for atomic.CompareAndSwapInt32(&lock, 1, 0) {
+	}
 }