Skip to content
Related Articles

Related Articles

atomic.LoadPointer() Function in Golang With Examples
  • Last Updated : 01 Apr, 2020

In Go language, atomic packages supply lower level atomic memory that is helpful is implementing synchronization algorithms. The LoadPointer() function in Go language is used to atomically load *addr. This function is defined under the atomic package. Here, you need to import “sync/atomic” and “unsafe” package in order to use these functions.

Syntax:

func LoadPointer(addr *unsafe.Pointer) (val unsafe.Pointer)

Here, addr indicates address.

Note: (*unsafe.Pointer) is the pointer to a unsafe.Pointer value. And unsafe.Pointer type is helpful in enabling transitions between arbitrary types and builtin uintptr type. Moreover, unsafe is a package that is helpful in type safety of Go programs.

Return Value: It automically loads *addr and returns unsafe.Pointer.



Example 1:

filter_none

edit
close

play_arrow

link
brightness_4
code

// Program to illustrate the usage of
// LoadPointer function in Golang
  
// Including main package
package main
  
// importing fmt, 
// sync/atomic and unsafe
import (
    "fmt"
    "sync/atomic"
    "unsafe"
)
  
// Defining a struct type L
type L struct{ x, y, z int }
  
// Declaring pointer 
// to L struct type
var PL *L
  
// Calling main
func main() {
  
    // Defining *addr unsafe.Pointer
    var unsafepL = (*unsafe.Pointer)(unsafe.Pointer(&PL))
  
    // Defining value 
    // of unsafe.Pointer
    var px L
  
    // Calling StorePointer and 
    // storing unsafe.Pointer
    // value to *addr
    atomic.StorePointer(
        unsafepL, unsafe.Pointer(&px))
  
    // Calling LoadPointer() method
    px1 := (*L)(atomic.LoadPointer(unsafepL))
  
    // Returns true if *addr is 
    // loaded else returns false
    fmt.Println(px1 == &px)
  
    // Prints unsafe.Pointer
    fmt.Println(&px1)
}

chevron_right


Output:

true
0xc0000b8018 // Can be different at different run times

Here, the StorePointer method adds value to the *addr and then LoadPointer method atomically loads *addr. So, here loading is accomplished hence, true is returned and the value of unsafe.Pointer returned here can be different at different run times.

Example 2:

filter_none

edit
close

play_arrow

link
brightness_4
code

// Program to illustrate the usage of
// LoadPointer function in Golang
  
// Including main package
package main
  
// importing fmt, 
// sync/atomic and unsafe
import (
    "fmt"
    "sync/atomic"
    "unsafe"
)
  
// Defining a struct type L
type L struct{ x, y, z int }
  
// Declaring pointer 
// to L struct type
var PL *L
  
// Calling main
func main() {
  
    // Defining *addr unsafe.Pointer
    var unsafepL = (*unsafe.Pointer)(unsafe.Pointer(&PL))
  
    // Defining value 
    // of unsafe.Pointer
    var px L
  
    // Calling LoadPointer() method
    px1 := (*L)(atomic.LoadPointer(unsafepL))
  
    // Returns true if *addr is 
    // loaded else returns false
    fmt.Println(px1 == &px)
  
    // Prints unsafe.Pointer
    fmt.Println(&px1)
}

chevron_right


Output:

false
0xc00000e028  // A random value is returned in each run

Here, false is returned as here the unsafe.pointer is not stored before so, LoadPointer() method was not able to load the *addr. Moreover, the address value returned here is the address of px1.

My Personal Notes arrow_drop_up
Recommended Articles
Page :