go原子操作 atomic

go原子操作 atomic

原子操作可以实现和sync.mux一样的

package main

import (
        "fmt"
        "sync"
)
var mux sync.Mutex


func main() {
        var count int32
        fmt.Println("main start...")
        var wg sync.WaitGroup
        for i:=0;i<50000;i++ {
                wg.Add(1)
                go func( i int){
                        defer wg.Done()
                        //fmt.Println("goroutine:",i,"start...")
                        //atomic.AddInt32(&count,1)
                        //count++
                        mux.Lock()
                        count++
                        mux.Unlock()
                        //fmt.Println("goroutine:",i,"count:",count,"end...")
                }(i)
        }
        wg.Wait()
        fmt.Println(count)

        fmt.Println("main end...")
}

package main

import (
        "fmt"
        "sync"
)
var mux sync.Mutex


func main() {
        var count int32
        fmt.Println("main start...")
        var wg sync.WaitGroup
        for i:=0;i<50000;i++ {
                wg.Add(1)
                go func( i int){
                        defer wg.Done()
                        //fmt.Println("goroutine:",i,"start...")
                        //atomic.AddInt32(&count,1)
                        //count++
                        mux.Lock()
                        count++
                        mux.Unlock()
                        //fmt.Println("goroutine:",i,"count:",count,"end...")
                }(i)
        }
        wg.Wait()
        fmt.Println(count)

        fmt.Println("main end...")
}

count++ 只有这个的时候结果不是五万

下面两个的结果都正确

mux.Lock()
count++
mux.Unlock()

atomic.AddInt32(&count,1)

package main

import (
        "fmt"
        "sync"
        "sync/atomic"
        "time"
)

type Counter interface {
        Inc()
        Load() int64
}

// 普通版
type CommonCounter struct {
        counter int64
}

func (c *CommonCounter) Inc() {
        c.counter++
}

func (c *CommonCounter) Load() int64 {
        return c.counter
}

// 互斥锁版
type MutexCounter struct {
        counter int64
        lock    sync.Mutex
}

func (m *MutexCounter) Inc() {
        m.lock.Lock()
        defer m.lock.Unlock()
        m.counter++
}

func (m *MutexCounter) Load() int64 {
        m.lock.Lock()
        defer m.lock.Unlock()
        return m.counter
}

// 原子操作版
type AtomicCounter struct {
        counter int64
}

func (a *AtomicCounter) Inc() {
        atomic.AddInt64(&a.counter, 1)
}

func (a *AtomicCounter) Load() int64 {
        return atomic.LoadInt64(&a.counter)
}

func test(c Counter) {
        var wg sync.WaitGroup
        start := time.Now()
        for i := 0; i < 2000; i++ {
                wg.Add(1)
                go func() {
                        c.Inc()
                        wg.Done()
                }()
        }
        wg.Wait()
        end := time.Now()
        fmt.Println(c.Load(), end.Sub(start))
}

func main() {
        c1 := CommonCounter{} // 非并发安全
        test(&c1)
        c2 := MutexCounter{} // 使用互斥锁实现并发安全
        test(&c2)
        c3 := AtomicCounter{} // 并发安全且比互斥锁效率更高
        test(&c3)
}