go 并发编程实践Day2

go 并发编程实践Day2

import (
	"fmt"
	"math"
	"os"
	"sync"
	"text/tabwriter"
	"time"
)

func Day2Main() {
	learnOnceDeadLock()
}

func learnOnceDeadLock(){
	var onceA, onceB sync.Once
	var initB func()
	initA := func() {onceB.Do(initB)}
	initB = func() {onceA.Do(initA)}
	onceA.Do(initA)
}

// 1
func learnOnce() {
	var count int
	increment := func() { count++ }
	decrement := func() { count-- }

	var once sync.Once
	fmt.Println(count)
	once.Do(increment)
	fmt.Println(count)
	once.Do(decrement)
	fmt.Println(count)
}

func learnCondBroadCast() {
	type Button struct {
		Clicked *sync.Cond
	}

	button := Button{Clicked: sync.NewCond(&sync.Mutex{})}
	subscribe := func(cond *sync.Cond, fn func()) {
		var goRunning sync.WaitGroup
		goRunning.Add(1)
		go func() {
			goRunning.Done()
			cond.L.Lock()
			defer cond.L.Unlock()
			cond.Wait()
			fn()
		}()
		goRunning.Wait()
	}

	var clickRegistered sync.WaitGroup
	clickRegistered.Add(3)
	subscribe(button.Clicked, func() {
		defer clickRegistered.Done()
		fmt.Println("Maximizing Window")
	})
	subscribe(button.Clicked, func() {
		defer clickRegistered.Done()
		fmt.Println("Displaying annoying dialog box!")
	})
	subscribe(button.Clicked, func() {
		defer clickRegistered.Done()
		fmt.Println("Mouse Clicked")
	})
	//button.Clicked.Broadcast()
	clickRegistered.Wait()
}

func learnCond() {
	cond := sync.NewCond(&sync.Mutex{})
	queue := make([]interface{}, 0, 10)

	removeQueue := func(delay time.Duration) {
		time.Sleep(delay)
		cond.L.Lock()
		queue = queue[1:]
		fmt.Println("removed from queue")
		cond.L.Unlock()
		cond.Signal()
	}
	for i := 0; i < 10; i++ {
		cond.L.Lock()
		for len(queue) == 2 {
			cond.Wait()
		}
		fmt.Println("Adding to queue")
		queue = append(queue, struct{}{})
		go removeQueue(1 * time.Second)
		cond.L.Unlock()
	}
}

func learnRwMutex() {
	producer := func(wg *sync.WaitGroup, locker sync.Locker) {
		defer wg.Done()
		for i := 0; i < 5; i++ {
			locker.Lock()
			locker.Unlock()
			time.Sleep(1)
		}
	}
	observer := func(wg *sync.WaitGroup, locker sync.Locker) {
		defer wg.Done()
		locker.Lock()
		defer locker.Unlock()
	}

	test := func(count int, mutex, rwMutex sync.Locker) time.Duration {
		var wg sync.WaitGroup
		wg.Add(count + 1)
		beginTestTime := time.Now()
		go producer(&wg, mutex)
		for i := count; i > 0; i-- {
			go observer(&wg, rwMutex)
		}
		wg.Wait()
		return time.Since(beginTestTime)
	}

	writer := tabwriter.NewWriter(os.Stdout, 0, 1, 2, ' ', 0)
	defer writer.Flush()

	var m sync.RWMutex
	fmt.Fprintf(writer, "Readers\tRWMutex\tMutex\n")
	for i := 0; i < 20; i++ {
		count := int(math.Pow(2, float64(i)))
		fmt.Fprintf(writer, "%d\t%v\t%v\n", count, test(count, &m, m.RLocker()), test(count, &m, &m))
	}
}

func learnLocker() {
	var count int
	var lock sync.Mutex

	increment := func() {
		lock.Lock()
		defer lock.Unlock()
		count++
		fmt.Printf("increment count = %d", count)
	}
	decrement := func() {
		lock.Lock()
		defer lock.Unlock()
		count--
		fmt.Printf("decrement count = %d", count)
	}

	var wg sync.WaitGroup
	const num = 5

	for i := 0; i < num; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			go increment()
		}()
	}

	for i := 0; i < num; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			go decrement()
		}()
	}
	wg.Wait()
	fmt.Println("finished")
}

func learnWaitGroup() {
	hello := func(wg *sync.WaitGroup, id int) {
		defer wg.Done()
		fmt.Printf("Hello from %v!\n", id)
	}
	const num = 5
	var wg sync.WaitGroup
	wg.Add(num)
	for i := 0; i < num; i++ {
		go hello(&wg, i+1)
	}
	wg.Wait()
}