Go多线程中数据不一致问题的解决方案(sync锁机制)

package main

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

// 定义全局变量 票库存为10张
var tickets int = 10

// 定义一个锁  Mutex 锁头
var mutex sync.Mutex

func main() {
    go saleTicket("张三")
    go saleTicket("李四")
    go saleTicket("王五")
    go saleTicket("赵六")

    time.Sleep(time.Second * 5)
}

// 售票函数
func saleTicket(name string) {
    for {
        // 在拿到共享资源之前先上锁
        mutex.Lock()
        if tickets > 0 {
            time.Sleep(time.Millisecond * 1)
            fmt.Println(name, "剩余票的数量为：", tickets)
            tickets--
        } else {
            // 票卖完，解锁
            mutex.Unlock()
            fmt.Println("票已售完")
            break
        }
        // 操作完毕后，解锁
        mutex.Unlock()
    }
}

package main

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

// waitgroup、

var wg sync.WaitGroup

func main() {
    // 公司最后关门的人   0
    // wg.Add(2) wg.Add(2)来告诉WaitGroup我们要等待两个Goroutine完成  开启几个协程，就add几个
    // wg.Done() 我告知我已经结束了  defer wg.Done()来在Goroutine完成时通知WaitGroup
    // 开启几个协程，就add几个
    wg.Add(2)

    go test1()
    go test2()

    fmt.Println("main等待ing")
    wg.Wait() // 等待 wg 归零，wg.Wait()来等待所有Goroutine完成 代码才会继续向下执行
    fmt.Println("end")

    // 理想状态：所有协程执行完毕之后，自动停止。
    //如果每次都强制设置个等待时间。那么协程代码也可能在这个时间内还没跑完，也可能提前就跑完了，所以设置死的等待时间不合理。此时就需要用到了等待组WaitGroup
    //time.Sleep(1 * time.Second)

}
func test1() {
    for i := 0; i < 10; i++ {
        time.Sleep(1 * time.Second)
        fmt.Println("test1--", i)
    }
    wg.Done() //这里就将该代码块放在了其他逻辑之后
}
func test2() {
    defer wg.Done() // defer wg.Done()来在Goroutine完成时通知WaitGroup  如果不用defer就得把该方法放在其他代码之后
    for i := 0; i < 10; i++ {
        fmt.Println("test2--", i)
    }
}

package main

import (
    "fmt"
    "sync"
)

var (
    data map[string]int
    rwMu sync.RWMutex
)

func readData(key string) int {
    rwMu.RLock()
    defer rwMu.RUnlock()
    return data[key]
}

func writeData(key string, value int) {
    rwMu.Lock()
    defer rwMu.Unlock()
    data[key] = value
}

func main() {
    data = make(map[string]int)

    var wg sync.WaitGroup

    // 写操作
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            writeData(fmt.Sprintf("key%d", i), i*10)
        }(i)
    }

    // 读操作
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            value := readData(fmt.Sprintf("key%d", i%10))
            fmt.Printf("Read: key%d = %d\n", i%10, value)
        }(i)
    }

    wg.Wait()
}

package main

import (
    "fmt"
    "sync"
)

var (
    once    sync.Once
    message string
)

func initMessage() {
    message = "Hello, World!"
}

func printMessage() {
    once.Do(initMessage)
    fmt.Println(message)
}

func main() {
    var wg sync.WaitGroup

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

    wg.Wait()
}