Golang中的atomic.Int64类型|极客笔记

Golang中的atomic.Int64类型

在并发编程中，我们经常会遇到共享数据的读写问题。在多个goroutine同时操作同一个变量时，如果不加以保护，可能会出现数据竞争导致程序出现意外的结果。为了解决这个问题，Go语言提供了atomic包，其中提供了一系列的原子操作函数，可以保证并发安全地操作数据。

本文将重点介绍atomic包中的Int64类型，以及如何使用它来保证对int64类型数据的原子操作。

什么是Atomic操作

在并发编程中，为了确保数据的一致性，我们需要使用原子操作。原子操作是指不可再分割的操作，要么全部执行成功，要么全部不执行。在Go语言中，atomic包提供了一组原子操作函数，可以确保对共享变量的操作是原子的，不会被中断。

atomic.Int64类型

atomic.Int64类型是atomic包中的其中一个类型，用来存储int64类型的数据，并提供了一系列的原子操作方法，包括Load、Store、Add、Sub、Swap等。通过使用atomic.Int64类型，可以保证在并发环境中对int64类型数据的操作是原子的。

原子操作方法

Load方法

atomic.Int64类型的Load方法用于获取当前的int64值，并返回当前值。这个操作是原子的，不会被中断。

package main

import (
    "fmt"
    "sync/atomic"
)

func main() {
    var number atomic.Int64
    number.Store(10)

    value := number.Load()
    fmt.Println(value)
}

运行结果为：

Store方法

atomic.Int64类型的Store方法用于设置新的int64值，并覆盖原来的值。这个操作是原子的，不会被中断。

package main

import (
    "fmt"
    "sync/atomic"
)

func main() {
    var number atomic.Int64

    number.Store(10)
    value := number.Load()
    fmt.Println(value)

    number.Store(20)
    value = number.Load()
    fmt.Println(value)
}

运行结果为：

10
20

Add方法

atomic.Int64类型的Add方法用于将给定的值与原值相加，并返回新的值。这个操作是原子的，不会被中断。

package main

import (
    "fmt"
    "sync/atomic"
)

func main() {
    var number atomic.Int64
    number.Store(10)

    value := number.Add(5)
    fmt.Println(value)

    value = number.Load()
    fmt.Println(value)
}

运行结果为：

15
15

Sub方法

atomic.Int64类型的Sub方法用于将给定的值与原值相减，并返回新的值。这个操作是原子的，不会被中断。

package main

import (
    "fmt"
    "sync/atomic"
)

func main() {
    var number atomic.Int64
    number.Store(10)

    value := number.Sub(5)
    fmt.Println(value)

    value = number.Load()
    fmt.Println(value)
}

运行结果为：

5
5

Swap方法

atomic.Int64类型的Swap方法用于设置新的int64值，并返回原来的值。这个操作是原子的，不会被中断。

package main

import (
    "fmt"
    "sync/atomic"
)

func main() {
    var number atomic.Int64
    number.Store(10)

    value := number.Swap(20)
    fmt.Println(value)

    value = number.Load()
    fmt.Println(value)
}

运行结果为：

10
20

原子操作示例

下面是一个使用atomic.Int64类型进行原子操作的示例，模拟多个goroutine对共享变量进行递增操作的场景。

package main

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

func main() {
    var number atomic.Int64
    var wg sync.WaitGroup

    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            for j := 0; j < 1000; j++ {
                number.Add(1)
            }
            wg.Done()
        }()
    }

    wg.Wait()

    fmt.Println(number.Load())
}

运行结果为：

在这个示例中，我们创建了1000个goroutine，并发安全地对共享的atomic.Int64类型变量进行递增操作，最后得到的结果是1000000，说明原子操作方法能够确保并发安全地操作数据。