go语言sync包的学习，Mutex、WaitGroup、Cond

package main;

import (
        "fmt"
        "sync"
        "runtime"
        "time"
)

//加锁，注意锁要以指针的形式传进来，不然只是拷贝
func total1(num *int, mu *sync.Mutex, ch chan bool) {
        mu.Lock();
        for i := 0; i < 1000; i++ {
                *num += i;
        }
        ch <- true;
        mu.Unlock();
}

//不加锁
func total2(num *int, ch chan bool) {
        for i := 0; i < 1000; i++ {
                *num += i;
        }
        ch <- true;
}

//Lock、Unlock与RLock、RUnlock不能嵌套使用
func total3(num *int, rwmu *sync.RWMutex, ch chan bool) {
        for i := 0; i < 1000; i++ {
                rwmu.Lock();
                *num += i;
                rwmu.Unlock();

                if(i == 500) {
                        //读锁定
                        rwmu.RLock();
                        fmt.Print(*num, " ");
                        rwmu.RUnlock();
                }
        }
        ch <- true;
}

func printNum(num int, cond *sync.Cond) {
        cond.L.Lock();
        if num < 5 {
                //num小于5时，进入等待状态
                cond.Wait();
        }
        //大于5的正常输出
        fmt.Println(num);
        cond.L.Unlock();
}

func main() {
        //Once.Do()保证多次调用只执行一次
        once := sync.Once{};
        ch := make(chan bool, 3);
        for i := 0; i < 3; i++ {
                go func(n int) {
                        once.Do(func() {
                                //只会执行一次，因为闭包引用了变量n，最后的值为2
                                fmt.Println(n)
                        });
                        //给chan发送true，表示执行完成
                        ch <- true;
                }(i);
        }
        for i := 0; i < 3; i++ {
                //读取三次chan,如果上面三次没执行完会一直阻塞
                <-ch;
        }

        //互斥锁，保证某一时刻只能有一个访问对象
        mutex := sync.Mutex{};
        ch2 := make(chan bool, 20);
        //使用多核，不然下面的结果会一样
        runtime.GOMAXPROCS(runtime.NumCPU());
        num1 := 0;
        num2 := 0;
        for i := 0; i < 10; i++ {
                go total1(&num1, &mutex, ch2);
        }
        for i := 0; i < 10; i++ {
                go total2(&num2, ch2);
        }
        for i := 0; i < 20; i++ {
                <-ch2;
        }
        //会发现num1与num2计算出的结果不一样
        //而num1的结果才是正确的，因为total2没有加锁，导致多个goroutine操作num时发生数据混乱
        fmt.Println(num1, num2);

        //读写锁，多了读锁定，和读解锁，让多个goroutine同时读取对象
        rwmutex := sync.RWMutex{};
        ch3 := make(chan bool, 10);
        num3 := 0;
        for i := 0; i < 10; i++ {
                go total3(&num3, &rwmutex, ch3);
        }
        for i := 0; i < 10; i++ {
                <-ch3;
        }
        fmt.Println(num3);

        //组等待，等待一组goroutine的结束
        wg := sync.WaitGroup{};
        //增加计数器
        wg.Add(10);
        for i:= 0; i< 10; i++ {
                go func(n int) {
                        fmt.Print(n, " ");
                        //这里表示该goroutine执行完成
                        wg.Done();
                }(i);
        }
        //等待所有线程执行完成
        wg.Wait();

        fmt.Println("");

        //条件等待
        mutex2 := sync.Mutex{};
        //使用锁创建一个条件等待
        cond := sync.NewCond(&mutex2);

        for i := 0; i < 10; i++ {
                go printNum(i, cond);
        }

        time.Sleep(time.Second * 1);
        //等待一秒后，我们先唤醒一个等待，输出一个数字
        cond.L.Lock()
        cond.Signal();
        cond.L.Unlock();
        time.Sleep(time.Second * 1);
        //再次待待一秒后，唤醒所有，输出余下四个数字
        cond.L.Lock()
        cond.Broadcast();
        cond.L.Unlock();
        time.Sleep(time.Second * 1);
}