Collection of common concurrency pitfalls tests

Author: miguelcnf

.gitignore

@@ -0,0 +1 @@
+.idea

README.md

@@ -0,0 +1,5 @@
+Collection of Go tests that show common concurrency problems:
+
+* [Race Condition](problems/race_test.go)
+* [Deadlock](problems/deadlock_test.go)
+* [Starvation](problems/starvation_test.go)

problems/deadlock_test.go

@@ -0,0 +1,27 @@
+package problems
+
+// Deadlock: blocking of concurrent threads that have a mutual dependency that is impossible to be satisfied.
+
+import (
+	"testing"
+)
+
+// block on the wait channel before writing to the done and ctl channels
+func deadlock(wait chan bool, done chan bool, ctl chan bool) {
+	<-wait
+	done <- true
+	ctl <- true
+}
+
+func Test_Deadlock(t *testing.T) {
+	c1 := make(chan bool)
+	c2 := make(chan bool)
+	ctl := make(chan bool)
+
+	// start mutual dependent go routines
+	go deadlock(c1, c2, ctl)
+	go deadlock(c2, c1, ctl)
+
+	<-ctl
+	<-ctl
+}

problems/race_test.go

@@ -0,0 +1,38 @@
+package problems
+
+// Race Conditions: concurrent threads changing shared data without sufficient protection mechanisms.
+
+import (
+	"testing"
+)
+
+const concurrency = 1000
+
+// shared memory
+var value = 0
+
+// change the value of unprotected shared memory
+func increment(done chan bool) {
+	value++
+	done <- true
+}
+
+func Test_RaceCondition(t *testing.T) {
+	done := make(chan bool, concurrency)
+
+	// start N go routines
+	for i := 0; i < concurrency; i++ {
+		go increment(done)
+	}
+
+	// wait for all go routines to finish
+	for i := 0; i < concurrency; i++ {
+		<-done
+	}
+
+	// assert that writes were lost due to race conditions
+	if value != concurrency {
+		t.Logf("expected value to be: %v but was: %v", concurrency, value)
+		t.Fatal()
+	}
+}

problems/starvation_test.go

@@ -0,0 +1,103 @@
+package problems
+
+// Starvation: threads are unable to progress due to greedy or high priority threads blocking shared resources.
+
+import (
+	"sync"
+	"testing"
+	"time"
+)
+
+// shared resource
+var l = &lock{}
+
+type lock struct {
+	m sync.Mutex
+}
+
+var thr = &threads{}
+
+type threads struct {
+	created  int
+	finished int
+	m        sync.Mutex
+}
+
+func (t *threads) create() {
+	t.m.Lock()
+	t.created++
+	t.m.Unlock()
+}
+
+func (t *threads) finish() {
+	t.m.Lock()
+	t.finished++
+	t.m.Unlock()
+}
+
+func (t *threads) values() (int, int) {
+	t.m.Lock()
+	defer t.m.Unlock()
+	return t.created, t.finished
+}
+
+// greedy function that locks the shared resource for a long time
+func greedy() {
+	l.m.Lock()
+	time.Sleep(2 * time.Second)
+	l.m.Unlock()
+}
+
+// normal function that locks the shared resource for a small amount of time
+func normal(finish chan bool) {
+	l.m.Lock()
+	time.Sleep(100 * time.Millisecond)
+	finish <- true
+	l.m.Unlock()
+}
+
+func Test_Starvation(t *testing.T) {
+	create := make(chan bool)
+	finish := make(chan bool)
+
+	// register created/finished thread counters
+	go func() {
+		for {
+			select {
+			case <-create:
+				thr.create()
+			case <-finish:
+				thr.finish()
+			}
+		}
+	}()
+
+	threads := time.Tick(100 * time.Millisecond)
+	stop := time.After(5 * time.Second)
+	greed := time.After(2 * time.Second)
+
+loop:
+	for {
+		select {
+		case <-greed:
+			// start a single greedy go routine after 2s
+			go greedy()
+		case <-threads:
+			// start a new normal go routine every 100ms
+			go normal(finish)
+			create <- true
+		case <-stop:
+			// wait 100ms to let normal go routines finish and break the loop after 5s
+			time.Sleep(100 * time.Millisecond)
+			break loop
+		}
+	}
+
+	c, f := thr.values()
+	if c != f {
+		// assert that number of finished threads is different than the number of created threads
+		t.Logf("number of created threads: %v", c)
+		t.Logf("number of finished threads: %v", f)
+		t.Fatal()
+	}
+}