Golang sync

Go1.9.2 sync库里包含下面几类：Mutex/RWMutex/Cond/WaitGroup/Once/Map/Pool

1.Mutex：互斥锁，等同于linux下的pthread_mutex_t

//多个线程同时运行，获得Mutex锁者线程优先执行，其余线程阻塞等待

func testMutex() {

    mutex := sync.Mutex{};

    for i := ; i < ; i++ {

        go func(idx int) {

            mutex.Lock();

            defer mutex.Unlock();

            fmt.Println("idx :=", idx);

            time.Sleep(time.Second);

        }(i)

    }

    time.Sleep( * time.Second);

    fmt.Println("Func finish.");

}

2.RWMutex：读写锁，等同于linux下的pthread_rwlock_t

//写请求在读锁和写锁时都必须阻塞等待，读请求只在写锁时阻塞等待

func testRWMutex() {

    rwMutex := sync.RWMutex{};

    for i := ; i < ; i++ {

        go func(idx int) {

            rwMutex.RLock();

            defer rwMutex.RUnlock();

            fmt.Println("Read Mutex :",idx);

        }(i);

        go func(idx int) {

            rwMutex.Lock();

            defer rwMutex.Unlock();

            fmt.Println("Write Mutex :",idx);

            time.Sleep(time.Second);

        }(i);

    }

    time.Sleep( * time.Second);

    fmt.Println("Func finish.");

}

3.Cond：条件变量，等同于linux下的pthread_cond_t

func testCond() {

    cond := sync.NewCond(&sync.Mutex{});

    cond.L.Lock(); //①上锁

    defer cond.L.Unlock();

    go func() {

        fmt.Println("go wait lock.");

        cond.L.Lock(); //②等Wait解锁

        defer cond.L.Unlock(); //⑤解锁后触发Wait

        defer fmt.Println("go unlock.");

        fmt.Println("go locked.");

        cond.Signal(); //④触发Wait等待解锁

    }()

    time.Sleep(time.Second);

    fmt.Println("start wait.");

    for {

        cond.Wait(); //③可以理解为立刻解锁并触发一个阻塞线程（如果没有阻塞线程则不触发）后立刻再上锁等待Signal信号

        fmt.Println("wait finish.");

        break;

    }

    time.Sleep(time.Second);

    fmt.Println("Func finish.");

}

4.WaitGroup：组等待

//Add 增加等待计数;Done减少等待计数；当计数为0时触发Wait;

func testWaitGroup() {

    waitGroup := sync.WaitGroup{};

    for i := ; i < ; i++ {

        waitGroup.Add();

        go func(idx int) {

            time.Sleep(time.Second);

            fmt.Println("go : ", idx);

            waitGroup.Done();

        }(i)

    }

    for{

        fmt.Println("start wait.");

        waitGroup.Wait();

        fmt.Println("wait finish.");

        break;

    }

    time.Sleep(time.Second);

    fmt.Println("Func finish.");

}

5.Once：只执行一次

//只执行一次以后不再触发

func testOnce() {

    once := sync.Once{};

    for i := ; i < ; i++ {

        go func(idx int) {

            once.Do(func() {

                fmt.Println("Do once : ", idx); //这里只执行一次

            })

            fmt.Println("go : ", idx);

        }(i)

    }

    time.Sleep( * time.Second);

    fmt.Println("Func finish.");

}

6.Map：线程安全map

func testMap() {

    syncMap := sync.Map{};

    for i := ; i < ; i++ {

        go func(idx int) {

            //如果没有则保存起来

            _, ok := syncMap.LoadOrStore(idx, " StrVal = "+strconv.FormatInt(int64(idx), ));

            if !ok {

                fmt.Println("Store idx = ",idx);

            }

        }(i)

        go func(idx int) {

            val, ok := syncMap.Load(idx);

            if ok {

                fmt.Println("Load success idx = ", idx, val);

            } else {

                fmt.Println("Load fail idx = ", idx)

            }

        }(i)

    }

    time.Sleep( * time.Second);

    fmt.Println("Func finish.");

}

7.Pool：线程安全对象池

func testPool() {

    p := &sync.Pool{

        New: func() interface{} {

            return -;

        },

    }

    for i := ; i < ; i++ {

        go func(idx int) {

            p.Put(idx);

        }(i)

    }

    //取出来的对象是无序的

    for i := ; i < ; i++ {

        go func() {

            val := p.Get();

            fmt.Println("Get val = ", val);

        }()

    }

    time.Sleep( * time.Second);

    fmt.Println("Func finish.");

}

使用Pool一定要注意一下问题：

1.用途仅仅是增加对象重用的几率，减少gc的负担，而开销方面也不是很便宜的。

2.GC会将Pool清理掉。

3.Get不能保证将Put进去的全部取出来！如下例子：

func testPoolPutGet(){

    myPool := &sync.Pool{

        New: func() interface{} {

            return ;

        },

    }

    myPool.Put() //放入1

    myPool.Put() //放入2

    time.Sleep(time.Second)

    p1 := myPool.Get().(int)

    fmt.Println(p1) // 获得2

    p2 := myPool.Get().(int)

    fmt.Println(p2) // 获得0，而不是1！

}

4.关于Pool的实现原理，可以参考《go语言的官方包sync.Pool的实现原理和适用场景》

以上。