Go sync模块

// A WaitGroup waits for a collection of goroutines to finish.
// The main goroutine calls Add to set the number of
// goroutines to wait for. Then each of the goroutines
// runs and calls Done when finished. At the same time,
// Wait can be used to block until all goroutines have finished.
//
// A WaitGroup must not be copied after first use.
type WaitGroup struct {
   noCopy noCopy

   // 64-bit value: high 32 bits are counter, low 32 bits are waiter count.
   // 64-bit atomic operations require 64-bit alignment, but 32-bit
   // compilers do not ensure it. So we allocate 12 bytes and then use
   // the aligned 8 bytes in them as state.
   state1 [12]byte
   sema   uint32
}

示例代码：

package main

import (

    "sync"

    "fmt"

)

func doWorker(id int, ch chan int, wg *sync.WaitGroup) {

    for n := range ch {

        fmt.Printf("Worker %d received %c\n", id, n)

        wg.Done()    // 减少一个计数

    }

}

type worker struct {

    in chan int

    wg *sync.WaitGroup

}

func createWorker(id int, wg *sync.WaitGroup) worker {

    w := worker{

        in: make(chan int),

        wg: wg,

    }

    go doWorker(id, w.in, wg)

    return w

}

func chanDemo() {

    var wg sync.WaitGroup

    var workers []worker

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

        workers[i] = createWorker(i, &wg)

    }

    for i, worker := range workers {

        wg.Add()      // 添加一个计数

        worker.in <- 'a' + i

    }

    wg.Wait()    // 阻塞，等待所有任务完成

}

func main() {

    chanDemo()

}

// A Mutex is a mutual exclusion lock.
// The zero value for a Mutex is an unlocked mutex.
//
// A Mutex must not be copied after first use.
type Mutex struct {
   state int32
   sema  uint32
}

示例代码：

package main

import (

    "sync"

    "fmt"

)

var x = 

func increment(wg *sync.WaitGroup, mu *sync.Mutex) {

    mu.Lock()

    x++

    mu.Unlock()

    wg.Done()

}

func main() {

    var wg sync.WaitGroup

    var mu sync.Mutex

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

        wg.Add()

        go increment(&wg, &mu)

    }

    wg.Wait()

    fmt.Println("final value of x", x)

}

// Do calls the function f if and only if Do is being called for the
// first time for this instance of Once. In other words, given
//     var once Once
// if once.Do(f) is called multiple times, only the first call will invoke f,
// even if f has a different value in each invocation. A new instance of
// Once is required for each function to execute.

示例代码：

package main

import (

    "fmt"

    "sync"

)

func One () {

    fmt.Println("One")

}

func Two() {

    fmt.Println("Two")

}

func main() {

    var once sync.Once

    for i, v := range make([]string, ) {

        once.Do(One)

        fmt.Println("count:", v, "---", i)

    }

}

执行结果：

One

count:  ---

count:  ---

count:  ---

count:  ---

count:  ---

count:  ---

count:  ---

count:  ---

count:  ---

count:  ---

巴特西

Go sync模块

最新文章

热门文章