feat(learning): 第40条 理解包内测试与包外测试的差别

Author: xian-jie.shen

chapter6/sources/go-channel-case-9.go

@@ -39,5 +39,4 @@ func main() {
 		}
 	}
 	fmt.Println("program end")
-	time.Sleep
 }

chapter6/sources/go-sync-package-1_test.go

@@ -32,3 +32,56 @@ func BenchmarkCriticalSectionSyncByChan(b *testing.B) {
 		criticalSectionSyncByChan()
 	}
 }
+
+var i int
+var j int
+var mut sync.Mutex
+var cha = make(chan struct{}, 1)
+
+func CriticalSectionSyncByMutex2() {
+	mut.Lock()
+	defer mut.Unlock()
+	_ = i
+}
+
+func CriticalSectionSyncByChan2() {
+	cha <- struct{}{}
+	_ = j
+	<-cha
+}
+
+func CriticalSectionSyncWriteByMutex2() {
+	mut.Lock()
+	defer mut.Unlock()
+	i++
+}
+
+func CriticalSectionSyncWriteByChan2() {
+	cha <- struct{}{}
+	j++
+	<-cha
+}
+
+func BenchmarkCriticalSectionSyncWriteByMutex2(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		CriticalSectionSyncWriteByMutex2()
+	}
+}
+
+func BenchmarkCriticalSectionSyncWriteByChan2(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		CriticalSectionSyncWriteByChan2()
+	}
+}
+
+func BenchmarkCriticalSectionSyncByMutex2(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		CriticalSectionSyncByMutex2()
+	}
+}
+
+func BenchmarkCriticalSectionSyncByChan2(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		CriticalSectionSyncByChan2()
+	}
+}

chapter6/sources/go-sync-package-2.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"fmt"
 	"log"
 	"sync"
 	"time"
@@ -11,7 +12,7 @@ type foo struct {
 	sync.Mutex
 }
 
-func main() {
+func CopySyncType() {
 	f := foo{n: 17}
 
 	go func(f foo) {
@@ -44,3 +45,45 @@ func main() {
 	f.Unlock()
 	log.Println("g1: unlock foo ok")
 }
+
+type clock struct {
+	i int
+	sync.Mutex
+}
+
+func CopySyncType2() {
+	s := clock{i: 1}
+
+	go func(c clock) {
+		for {
+			fmt.Println("g1 try lock...")
+			c.Lock()
+			fmt.Println("g1 lock")
+			time.Sleep(3 * time.Second)
+			c.Unlock()
+			fmt.Println("g1 unlock")
+		}
+	}(s)
+
+	s.Lock()
+	fmt.Println("g0 lock")
+	go func(c clock) {
+		for {
+			fmt.Println("g2 try lock...")
+			c.Lock()
+			fmt.Println("g2 lock")
+			time.Sleep(5 * time.Second)
+			c.Unlock()
+			fmt.Println("g2 unlock")
+		}
+	}(s)
+
+	time.Sleep(1000 * time.Second)
+	s.Unlock()
+	fmt.Println("g0 unlock")
+}
+
+func main() {
+	// CopySyncType()
+	CopySyncType2()
+}

chapter6/sources/go-sync-package-3_test-copy.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+	"sync"
+	"testing"
+)
+
+var cs1 = 0 // 模拟临界区要保护的数据
+var mu1 sync.Mutex
+var cs2 = 0 // 模拟临界区要保护的数据
+var mu2 sync.RWMutex
+
+func BenchmarkReadSyncByMutex(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			mu1.Lock()
+			_ = cs1
+			mu1.Unlock()
+		}
+	})
+}
+
+func BenchmarkReadSyncByRWMutex(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			mu2.RLock()
+			_ = cs2
+			mu2.RUnlock()
+		}
+	})
+}
+
+func BenchmarkWriteSyncByRWMutex(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			mu2.Lock()
+			cs2++
+			mu2.Unlock()
+		}
+	})
+}

chapter6/sources/go-sync-package-3_test.go

@@ -5,37 +5,67 @@ import (
 	"testing"
 )
 
-var cs1 = 0 // 模拟临界区要保护的数据
-var mu1 sync.Mutex
-var cs2 = 0 // 模拟临界区要保护的数据
-var mu2 sync.RWMutex
-
-func BenchmarkReadSyncByMutex(b *testing.B) {
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			mu1.Lock()
-			_ = cs1
-			mu1.Unlock()
+var data1 int
+var mut1 sync.Mutex
+var data2 int
+var mut2 sync.RWMutex
+
+func BenchmarkSyncReadByMutex(b *testing.B) {
+	b.RunParallel(func(b *testing.PB) {
+		for b.Next() {
+			mut1.Lock()
+			_ = data1
+			mut1.Unlock()
+		}
+	})
+}
+
+func BenchmarkSyncReadByRWMutexRLock(b *testing.B) {
+	b.RunParallel(func(b *testing.PB) {
+		for b.Next() {
+			mut2.RLock()
+			_ = data1
+			mut2.RUnlock()
+		}
+	})
+}
+
+func BenchmarkSyncReadByRWMutexLock(b *testing.B) {
+	b.RunParallel(func(b *testing.PB) {
+		for b.Next() {
+			mut2.Lock()
+			_ = data1
+			mut2.Unlock()
+		}
+	})
+}
+
+func BenchmarkSyncWriteByMutex(b *testing.B) {
+	b.RunParallel(func(b *testing.PB) {
+		for b.Next() {
+			mut1.Lock()
+			data1++
+			mut1.Unlock()
 		}
 	})
 }
 
-func BenchmarkReadSyncByRWMutex(b *testing.B) {
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			mu2.RLock()
-			_ = cs2
-			mu2.RUnlock()
+func BenchmarkSyncWriteByRWMutexRLock(b *testing.B) {
+	b.RunParallel(func(b *testing.PB) {
+		for b.Next() {
+			mut2.RLock()
+			data1++
+			mut2.RUnlock()
 		}
 	})
 }
 
-func BenchmarkWriteSyncByRWMutex(b *testing.B) {
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			mu2.Lock()
-			cs2++
-			mu2.Unlock()
+func BenchmarkSyncWriteByRWMutexLock(b *testing.B) {
+	b.RunParallel(func(b *testing.PB) {
+		for b.Next() {
+			mut2.Lock()
+			data1++
+			mut2.Unlock()
 		}
 	})
 }

chapter6/sources/go-sync-package-4.go

@@ -46,7 +46,7 @@ func spawnGroup(f func(i int), num int, mu *sync.Mutex) <-chan signal {
 	return c
 }
 
-func main() {
+func showSyncPkg1() {
 	fmt.Println("start a group of workers...")
 	mu := &sync.Mutex{}
 	c := spawnGroup(worker, 5, mu)
@@ -60,4 +60,72 @@ func main() {
 
 	<-c
 	fmt.Println("the group of workers work done!")
+
+}
+
+func work(duration int) {
+	fmt.Println("worker start")
+	time.Sleep(time.Millisecond * time.Duration(duration))
+	fmt.Println("worker end")
+}
+
+var ready2 bool
+var mutex sync.Mutex
+
+func spawnGoroutine(f func(i int), nums int, cond *sync.Cond) <-chan struct{} {
+	done := make(chan struct{})
+	var wg sync.WaitGroup
+	for i := 0; i < nums; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			cond.L.Lock()
+			if !ready2 {
+				cond.Wait()
+			}
+			cond.L.Unlock()
+			f(i)
+			// for {
+			// 	mu.Lock()
+			// 	if !ready2 {
+			// 		mu.Unlock()
+			// 		// fmt.Printf("goroutine-%d: not ready..", i)
+			// 		time.Sleep(time.Second)
+			// 		continue
+			// 	}
+			// 	mu.Unlock()
+			// 	f(i)
+			// 	return
+			// }
+		}(i)
+	}
+
+	go func() {
+		wg.Wait()
+		done <- struct{}{}
+	}()
+
+	return done
+}
+
+func showSyncPkg2() {
+	// mu := &sync.Mutex{}
+	cond := sync.NewCond(&sync.Mutex{})
+	c := spawnGoroutine(work, 5, cond)
+	fmt.Println("exec group workers")
+	time.Sleep(5 * time.Second)
+
+	cond.L.Lock()
+	ready2 = true
+	cond.Broadcast()
+	fmt.Println("trigger worker")
+	cond.L.Unlock()
+
+	<-c
+	fmt.Println("all worker done")
+}
+
+func main() {
+	// showSyncPkg1()
+	showSyncPkg2()
 }

chapter6/sources/go-sync-package-6.go

@@ -28,7 +28,7 @@ func GetInstance(id int) *Foo {
 	return instance
 }
 
-func main() {
+func showOnceDo() {
 	var wg sync.WaitGroup
 	for i := 0; i < 5; i++ {
 		wg.Add(1)
@@ -45,3 +45,49 @@ func main() {
 	wg.Wait()
 	log.Printf("all goroutines exit\n")
 }
+
+type inst struct {
+}
+
+var ist *inst
+
+// var instance *Foo
+var once2 sync.Once
+
+func getInst(id int) *inst {
+	log.Printf("goroutine-%d: enter getInst", id)
+	defer func() {
+		if p := recover(); p != nil {
+			log.Println("caught a panic: ", p)
+		}
+	}()
+	once2.Do(func() {
+		ist = &inst{}
+		log.Printf("goroutine-%d: getInst: %p\n", id, ist)
+		panic("raise a panic")
+	})
+	return ist
+}
+
+func showOnceDo2() {
+	var wg sync.WaitGroup
+	for i := 0; i < 5; i++ {
+		wg.Add(1)
+		go func(id int) {
+			defer wg.Done()
+			ist := getInst(id)
+			log.Printf("goroutine-%d: instance: %+v %p\n", id, ist, ist)
+		}(i + 1)
+	}
+	time.Sleep(5 * time.Second)
+	ist := getInst(0)
+	log.Printf("goroutine-%d: get instance: %p\n", 0, ist)
+
+	wg.Wait()
+	log.Println("done")
+}
+
+func main() {
+	// showOnceDo()
+	showOnceDo2()
+}