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 := 0; i < 10; i++ {
        go func(idx int) {
            mutex.Lock();
            defer mutex.Unlock();
            fmt.Println("idx :=", idx);
            time.Sleep(time.Second);
        }(i)
    }

    time.Sleep(20 * time.Second);
    fmt.Println("Func finish.");
}

 

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

//写请求在读锁和写锁时都必须阻塞等待，读请求只在写锁时阻塞等待
func testRWMutex() {
    rwMutex := sync.RWMutex{};
    for i := 0; i < 10; 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(20 * 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 := 0; i < 10; i++ {
        waitGroup.Add(1);

        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 := 0; i < 10; i++ {
        go func(idx int) {
            once.Do(func() {
                fmt.Println("Do once : ", idx); //这里只执行一次
            })

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

    time.Sleep(5 * time.Second);
    fmt.Println("Func finish.");
}

 

6.Map：线程安全map

func testMap() {
    syncMap := sync.Map{};
    for i := 0; i < 10; i++ {
        go func(idx int) {
            //如果没有则保存起来
            _, ok := syncMap.LoadOrStore(idx, " StrVal = "+strconv.FormatInt(int64(idx), 10));
            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(5 * time.Second);
    fmt.Println("Func finish.");
}

 

7.Pool：线程安全对象池

func testPool() {
    p := &sync.Pool{
        New: func() interface{} {
            return -1;
        },
    }

    for i := 0; i < 10; i++ {
        go func(idx int) {
            p.Put(idx);
        }(i)
    }
    
    //取出来的对象是无序的
    for i := 0; i < 20; i++ {
        go func() {
            val := p.Get();
            fmt.Println("Get val = ", val);
        }()
    }

    time.Sleep(5 * time.Second);
    fmt.Println("Func finish.");
}

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

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

2.GC会将Pool清理掉。

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

func testPoolPutGet(){
    myPool := &sync.Pool{
        New: func() interface{} {
            return 0;
        },
    }

    myPool.Put(1) //放入1
    myPool.Put(2) //放入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的实现原理和适用场景》

以上。