atomic

package
v1.26.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 16, 2026 License: MIT Imports: 1 Imported by: 0

Documentation

Overview

atomicパッケージは、同期アルゴリズムの実装に役立つ 低レベルのアトミックメモリプリミティブを提供します。

これらの関数は、正しく使用するためには非常に注意が必要です。 特別な低レベルのアプリケーションを除き、同期はチャネルや[sync]パッケージの機能を 使用して行う方が良いです。 メモリを共有するために通信を行い、 メモリを共有するために通信を行わないでください。

SwapT関数によって実装されるスワップ操作は、アトミックの 相当するものです： 

old = *addr
*addr = new
return old

CompareAndSwapT関数によって実装される比較交換操作は、アトミックの 相当するものです： 

if *addr == old {
	*addr = new
	return true
}
return false

AddT関数によって実装される加算操作は、アトミックの 相当するものです： 

*addr += delta
return *addr

LoadTおよびStoreT関数によって実装されるロードおよびストア操作は、 "return *addr"および"*addr = val"のアトミック相当です。

the Go memory model の用語では、アトミック操作Aの効果が アトミック操作Bによって観察される場合、AはBの前に「同期する」。 さらに、プログラムで実行されるすべてのアトミック操作は、 あたかも一貫した順序で実行されるかのように振る舞います。 この定義は、C++の一貫性のあるアトミックとJavaのvolatile変数と 同じセマンティクスを提供します。

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func AddInt32 

func AddInt32(addr *int32, delta int32) (new int32)

AddInt32は、deltaを*addrにアトミックに加算し、新しい値を返します。 より使いやすく、エラーが発生しにくい Int32.Add の使用を検討してください。

func AddInt64 

func AddInt64(addr *int64, delta int64) (new int64)

AddInt64 は *addr に delta をアトミックに加算し、新しい値を返します。 より人間工学的でエラーが起きにくい Int64.Add の使用を検討してください （32 ビットプラットフォームをターゲットにする場合は特にご注意ください。bugs セクションを参照）。

func AddUint32 

func AddUint32(addr *uint32, delta uint32) (new uint32)

AddUint32は、deltaを*addrにアトミックに加算し、新しい値を返します。 xから符号付き正の定数値cを減算するには、AddUint32(&x, ^uint32(c-1))を使用します。 特に、xをデクリメントするには、AddUint32(&x, ^uint32(0))を使用します。 より使いやすく、エラーが発生しにくい Uint32.Add の使用を検討してください。

func AddUint64 

func AddUint64(addr *uint64, delta uint64) (new uint64)

AddUint64 は *addr に delta をアトミックに加算し、新しい値を返します。 x から符号付き正の定数値 c を減算するには AddUint64(&x, ^uint64(c-1)) を実行します。 特に x をデクリメントするには AddUint64(&x, ^uint64(0)) を実行します。 より人間工学的でエラーが起きにくい Uint64.Add の使用を検討してください （32 ビットプラットフォームをターゲットにする場合は特にご注意ください。bugs セクションを参照）。

func AddUintptr 

func AddUintptr(addr *uintptr, delta uintptr) (new uintptr)

AddUintptrは、deltaを*addrにアトミックに加算し、新しい値を返します。 より使いやすく、エラーが発生しにくい Uintptr.Add の使用を検討してください。

func AndInt32 added in v1.23.0 

func AndInt32(addr *int32, mask int32) (old int32)

AndInt32は、指定されたマスクを使って*addr上でビット単位のAND操作をアトミックに実行し、古い値を返します。 より使いやすく、エラーが発生しにくい Int32.And の使用を検討してください。

func AndInt64 added in v1.23.0 

func AndInt64(addr *int64, mask int64) (old int64)

AndInt64 は mask で指定されたビットマスクを使って *addr にビットAND演算を アトミックに実行し、古い値を返します。 より人間工学的でエラーが起きにくい Int64.And の使用を検討してください。

func AndUint32 added in v1.23.0 

func AndUint32(addr *uint32, mask uint32) (old uint32)

AndUint32は、指定されたマスクを使って*addr上でビット単位のAND操作をアトミックに実行し、古い値を返します。 より使いやすく、エラーが発生しにくい Uint32.And の使用を検討してください。

func AndUint64 added in v1.23.0 

func AndUint64(addr *uint64, mask uint64) (old uint64)

AndUint64 は mask で指定されたビットマスクを使って *addr にビットAND演算を アトミックに実行し、古い値を返します。 より人間工学的でエラーが起きにくい Uint64.And の使用を検討してください。

func AndUintptr added in v1.23.0 

func AndUintptr(addr *uintptr, mask uintptr) (old uintptr)

AndUintptrは、指定されたマスクを使って*addr上でビット単位のAND操作をアトミックに実行し、古い値を返します。 より使いやすく、エラーが発生しにくい Uintptr.And の使用を検討してください。

func CompareAndSwapInt32 

func CompareAndSwapInt32(addr *int32, old, new int32) (swapped bool)

CompareAndSwapInt32は、int32値のための比較交換操作を実行します。 より使いやすく、エラーが発生しにくい Int32.CompareAndSwap の使用を検討してください。

func CompareAndSwapInt64 

func CompareAndSwapInt64(addr *int64, old, new int64) (swapped bool)

CompareAndSwapInt64 は int64 値に対するコンペアアンドスワップ操作を実行します。 より人間工学的でエラーが起きにくい Int64.CompareAndSwap の使用を検討してください （32 ビットプラットフォームをターゲットにする場合は特にご注意ください。bugs セクションを参照）。

func CompareAndSwapPointer 

func CompareAndSwapPointer(addr *unsafe.Pointer, old, new unsafe.Pointer) (swapped bool)

CompareAndSwapPointerは、unsafe.Pointer値のための比較交換操作を実行します。 より使いやすく、エラーが発生しにくい Pointer.CompareAndSwap の使用を検討してください。

func CompareAndSwapUint32 

func CompareAndSwapUint32(addr *uint32, old, new uint32) (swapped bool)

CompareAndSwapUint32は、uint32値のための比較交換操作を実行します。 より使いやすく、エラーが発生しにくい Uint32.CompareAndSwap の使用を検討してください。

func CompareAndSwapUint64 

func CompareAndSwapUint64(addr *uint64, old, new uint64) (swapped bool)

CompareAndSwapUint64 は uint64 値に対するコンペアアンドスワップ操作を実行します。 より人間工学的でエラーが起きにくい Uint64.CompareAndSwap の使用を検討してください （32 ビットプラットフォームをターゲットにする場合は特にご注意ください。bugs セクションを参照）。

func CompareAndSwapUintptr 

func CompareAndSwapUintptr(addr *uintptr, old, new uintptr) (swapped bool)

CompareAndSwapUintptrは、uintptr値のための比較交換操作を実行します。 より使いやすく、エラーが発生しにくい Uintptr.CompareAndSwap の使用を検討してください。

func LoadInt32 

func LoadInt32(addr *int32) (val int32)

LoadInt32はアトミックに*addrをロードします。 より使いやすく、エラーが発生しにくい Int32.Load の使用を検討してください。

func LoadInt64 

func LoadInt64(addr *int64) (val int64)

LoadInt64 は *addr をアトミックにロードします。 より人間工学的でエラーが起きにくい Int64.Load の使用を検討してください （32 ビットプラットフォームをターゲットにする場合は特にご注意ください。bugs セクションを参照）。

func LoadPointer 

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

LoadPointerはアトミックに*addrをロードします。 より使いやすく、エラーが発生しにくい Pointer.Load の使用を検討してください。

func LoadUint32 

func LoadUint32(addr *uint32) (val uint32)

LoadUint32はアトミックに*addrをロードします。 より使いやすく、エラーが発生しにくい Uint32.Load の使用を検討してください。

func LoadUint64 

func LoadUint64(addr *uint64) (val uint64)

LoadUint64 は *addr をアトミックにロードします。 より人間工学的でエラーが起きにくい Uint64.Load の使用を検討してください （32 ビットプラットフォームをターゲットにする場合は特にご注意ください。bugs セクションを参照）。

func LoadUintptr 

func LoadUintptr(addr *uintptr) (val uintptr)

LoadUintptrはアトミックに*addrをロードします。 より使いやすく、エラーが発生しにくい Uintptr.Load の使用を検討してください。

func OrInt32 added in v1.23.0 

func OrInt32(addr *int32, mask int32) (old int32)

OrInt32は、指定されたマスクを使って*addr上でビット単位のOR操作をアトミックに実行し、古い値を返します。 より使いやすく、エラーが発生しにくい Int32.Or の使用を検討してください。

func OrInt64 added in v1.23.0 

func OrInt64(addr *int64, mask int64) (old int64)

OrInt64 は mask で指定されたビットマスクを使って *addr にビットOR演算を アトミックに実行し、古い値を返します。 より人間工学的でエラーが起きにくい Int64.Or の使用を検討してください。

func OrUint32 added in v1.23.0 

func OrUint32(addr *uint32, mask uint32) (old uint32)

OrUint32は、指定されたマスクを使って*addr上でビット単位のOR操作をアトミックに実行し、古い値を返します。 より使いやすく、エラーが発生しにくい Uint32.Or の使用を検討してください。

func OrUint64 added in v1.23.0 

func OrUint64(addr *uint64, mask uint64) (old uint64)

OrUint64 は mask で指定されたビットマスクを使って *addr にビットOR演算を アトミックに実行し、古い値を返します。 より人間工学的でエラーが起きにくい Uint64.Or の使用を検討してください。

func OrUintptr added in v1.23.0 

func OrUintptr(addr *uintptr, mask uintptr) (old uintptr)

OrUintptrは、指定されたマスクを使って*addr上でビット単位のOR操作をアトミックに実行し、古い値を返します。 より使いやすく、エラーが発生しにくい Uintptr.Or の使用を検討してください。

func StoreInt32 

func StoreInt32(addr *int32, val int32)

StoreInt32は、valを*addrにアトミックに格納します。 より使いやすく、エラーが発生しにくい Int32.Store の使用を検討してください。

func StoreInt64 

func StoreInt64(addr *int64, val int64)

StoreInt64 は val を *addr にアトミックに格納します。 より人間工学的でエラーが起きにくい Int64.Store の使用を検討してください （32 ビットプラットフォームをターゲットにする場合は特にご注意ください。bugs セクションを参照）。

func StorePointer 

func StorePointer(addr *unsafe.Pointer, val unsafe.Pointer)

StorePointerはアトミックにvalを*addrに格納します。 より使いやすく、エラーが発生しにくい Pointer.Store の使用を検討してください。

func StoreUint32 

func StoreUint32(addr *uint32, val uint32)

StoreUint32は、valを*addrにアトミックに格納します。 より使いやすく、エラーが発生しにくい Uint32.Store の使用を検討してください。

func StoreUint64 

func StoreUint64(addr *uint64, val uint64)

StoreUint64 は val を *addr にアトミックに格納します。 より人間工学的でエラーが起きにくい Uint64.Store の使用を検討してください （32 ビットプラットフォームをターゲットにする場合は特にご注意ください。bugs セクションを参照）。

func StoreUintptr 

func StoreUintptr(addr *uintptr, val uintptr)

StoreUintptrは、valを*addrにアトミックに格納します。 より使いやすく、エラーが発生しにくい Uintptr.Store の使用を検討してください。

func SwapInt32 added in v1.2.0 

func SwapInt32(addr *int32, new int32) (old int32)

SwapInt32は、*addrにnewをアトミックに格納し、以前の*addrの値を返します。 より使いやすく、エラーが発生しにくい Int32.Swap の使用を検討してください。

func SwapInt64 added in v1.2.0 

func SwapInt64(addr *int64, new int64) (old int64)

SwapInt64 は *addr に new をアトミックに格納し、以前の *addr の値を返します。 より人間工学的でエラーが起きにくい Int64.Swap の使用を検討してください （32 ビットプラットフォームをターゲットにする場合は特にご注意ください。bugs セクションを参照）。

func SwapPointer added in v1.2.0 

func SwapPointer(addr *unsafe.Pointer, new unsafe.Pointer) (old unsafe.Pointer)

SwapPointerはアトミックに新しい値を*addrに格納し、前の*addrの値を返します。 より使いやすく、エラーが発生しにくい Pointer.Swap の使用を検討してください。

func SwapUint32 added in v1.2.0 

func SwapUint32(addr *uint32, new uint32) (old uint32)

SwapUint32は、*addrにnewをアトミックに格納し、以前の*addrの値を返します。 より使いやすく、エラーが発生しにくい Uint32.Swap の使用を検討してください。

func SwapUint64 added in v1.2.0 

func SwapUint64(addr *uint64, new uint64) (old uint64)

SwapUint64 は *addr に new をアトミックに格納し、以前の *addr の値を返します。 より人間工学的でエラーが起きにくい Uint64.Swap の使用を検討してください （32 ビットプラットフォームをターゲットにする場合は特にご注意ください。bugs セクションを参照）。

func SwapUintptr added in v1.2.0 

func SwapUintptr(addr *uintptr, new uintptr) (old uintptr)

SwapUintptrは、*addrにnewをアトミックに格納し、以前の*addrの値を返します。 より使いやすく、エラーが発生しにくい Uintptr.Swap の使用を検討してください。

Types

type Bool added in v1.19.0 

type Bool struct {
	// contains filtered or unexported fields
}

Boolはアトミックなブール値です。 ゼロ値はfalseです。

Boolは最初に使用した後でコピーしてはいけません。

func (*Bool) CompareAndSwap added in v1.19.0 

func (x *Bool) CompareAndSwap(old, new bool) (swapped bool)

CompareAndSwapは、ブール値xの比較交換操作を実行します。

func (*Bool) Load added in v1.19.0 

func (x *Bool) Load() bool

Loadはアトミックにxに格納されている値をロードして返します。

func (*Bool) Store added in v1.19.0 

func (x *Bool) Store(val bool)

Storeはアトミックにvalをxに格納します。

func (*Bool) Swap added in v1.19.0 

func (x *Bool) Swap(new bool) (old bool)

Swapはアトミックにnewをxに格納し、前の値を返します。

type Int32 added in v1.19.0 

type Int32 struct {
	// contains filtered or unexported fields
}

Int32はアトミックなint32です。ゼロ値はゼロです。

Int32は最初に使用した後でコピーしてはいけません。

func (*Int32) Add added in v1.19.0 

func (x *Int32) Add(delta int32) (new int32)

Addはアトミックにdeltaをxに加え、新しい値を返します。

func (*Int32) And added in v1.23.0 

func (x *Int32) And(mask int32) (old int32)

Andは、提供されたマスクとしてビットマスクを使用してx上でビット単位のAND操作をアトミックに実行し、 古い値を返します。

func (*Int32) CompareAndSwap added in v1.19.0 

func (x *Int32) CompareAndSwap(old, new int32) (swapped bool)

CompareAndSwapは、xの比較交換操作を実行します。

func (*Int32) Load added in v1.19.0 

func (x *Int32) Load() int32

Loadはアトミックにxに格納されている値をロードして返します。

func (*Int32) Or added in v1.23.0 

func (x *Int32) Or(mask int32) (old int32)

Orは、提供されたマスクとしてビットマスクを使用してx上でビット単位のOR操作をアトミックに実行し、 古い値を返します。

func (*Int32) Store added in v1.19.0 

func (x *Int32) Store(val int32)

Storeはアトミックにvalをxに格納します。

func (*Int32) Swap added in v1.19.0 

func (x *Int32) Swap(new int32) (old int32)

Swapはアトミックにnewをxに格納し、前の値を返します。

type Int64 added in v1.19.0 

type Int64 struct {
	// contains filtered or unexported fields
}

Int64はアトミックなint64です。ゼロ値はゼロです。

Int64は最初に使用した後でコピーしてはいけません。

func (*Int64) Add added in v1.19.0 

func (x *Int64) Add(delta int64) (new int64)

Addはアトミックにdeltaをxに加え、新しい値を返します。

func (*Int64) And added in v1.23.0 

func (x *Int64) And(mask int64) (old int64)

Andは、提供されたマスクとしてビットマスクを使用してx上でビット単位のAND操作をアトミックに実行し、 古い値を返します。

func (*Int64) CompareAndSwap added in v1.19.0 

func (x *Int64) CompareAndSwap(old, new int64) (swapped bool)

CompareAndSwapは、xの比較交換操作を実行します。

func (*Int64) Load added in v1.19.0 

func (x *Int64) Load() int64

Loadはアトミックにxに格納されている値をロードして返します。

func (*Int64) Or added in v1.23.0 

func (x *Int64) Or(mask int64) (old int64)

Orは、提供されたマスクとしてビットマスクを使用してx上でビット単位のOR操作をアトミックに実行し、 古い値を返します。

func (*Int64) Store added in v1.19.0 

func (x *Int64) Store(val int64)

Storeはアトミックにvalをxに格納します。

func (*Int64) Swap added in v1.19.0 

func (x *Int64) Swap(new int64) (old int64)

Swapはアトミックにnewをxに格納し、前の値を返します。

type Pointer added in v1.19.0 

type Pointer[T any] struct {
	// contains filtered or unexported fields
}

Pointerは型*Tのアトミックなポインタです。ゼロ値はnil *Tです。

Pointerは最初に使用した後でコピーしてはいけません。

func (*Pointer[T]) CompareAndSwap added in v1.19.0 

func (x *Pointer[T]) CompareAndSwap(old, new *T) (swapped bool)

CompareAndSwapは、ポインタxの比較交換操作を実行します。

func (*Pointer[T]) Load added in v1.19.0 

func (x *Pointer[T]) Load() *T

Loadはアトミックにxに格納されている値をロードして返します。

func (*Pointer[T]) Store added in v1.19.0 

func (x *Pointer[T]) Store(val *T)

Storeはアトミックにvalをxに格納します。

func (*Pointer[T]) Swap added in v1.19.0 

func (x *Pointer[T]) Swap(new *T) (old *T)

Swapはアトミックにnewをxに格納し、前の値を返します。

type Uint32 added in v1.19.0 

type Uint32 struct {
	// contains filtered or unexported fields
}

Uint32はアトミックなuint32です。ゼロ値はゼロです。

Uint32は最初に使用した後でコピーしてはいけません。

func (*Uint32) Add added in v1.19.0 

func (x *Uint32) Add(delta uint32) (new uint32)

Addはアトミックにdeltaをxに加え、新しい値を返します。

func (*Uint32) And added in v1.23.0 

func (x *Uint32) And(mask uint32) (old uint32)

Andは、提供されたマスクとしてビットマスクを使用してx上でビット単位のAND操作をアトミックに実行し、 古い値を返します。

func (*Uint32) CompareAndSwap added in v1.19.0 

func (x *Uint32) CompareAndSwap(old, new uint32) (swapped bool)

CompareAndSwapは、xの比較交換操作を実行します。

func (*Uint32) Load added in v1.19.0 

func (x *Uint32) Load() uint32

Loadはアトミックにxに格納されている値をロードして返します。

func (*Uint32) Or added in v1.23.0 

func (x *Uint32) Or(mask uint32) (old uint32)

Orは、提供されたマスクとしてビットマスクを使用してx上でビット単位のOR操作をアトミックに実行し、 古い値を返します。

func (*Uint32) Store added in v1.19.0 

func (x *Uint32) Store(val uint32)

Storeはアトミックにvalをxに格納します。

func (*Uint32) Swap added in v1.19.0 

func (x *Uint32) Swap(new uint32) (old uint32)

Swapはアトミックにnewをxに格納し、前の値を返します。

type Uint64 added in v1.19.0 

type Uint64 struct {
	// contains filtered or unexported fields
}

Uint64はアトミックなuint64です。ゼロ値はゼロです。

Uint64は最初に使用した後でコピーしてはいけません。

func (*Uint64) Add added in v1.19.0 

func (x *Uint64) Add(delta uint64) (new uint64)

Addはアトミックにdeltaをxに加え、新しい値を返します。

func (*Uint64) And added in v1.23.0 

func (x *Uint64) And(mask uint64) (old uint64)

Andは、提供されたマスクとしてビットマスクを使用してx上でビット単位のAND操作をアトミックに実行し、 古い値を返します。

func (*Uint64) CompareAndSwap added in v1.19.0 

func (x *Uint64) CompareAndSwap(old, new uint64) (swapped bool)

CompareAndSwapは、xの比較交換操作を実行します。

func (*Uint64) Load added in v1.19.0 

func (x *Uint64) Load() uint64

Loadはアトミックにxに格納されている値をロードして返します。

func (*Uint64) Or added in v1.23.0 

func (x *Uint64) Or(mask uint64) (old uint64)

Orは、提供されたマスクとしてビットマスクを使用してx上でビット単位のOR操作をアトミックに実行し、 古い値を返します。

func (*Uint64) Store added in v1.19.0 

func (x *Uint64) Store(val uint64)

Storeはアトミックにvalをxに格納します。

func (*Uint64) Swap added in v1.19.0 

func (x *Uint64) Swap(new uint64) (old uint64)

Swapはアトミックにnewをxに格納し、前の値を返します。

type Uintptr added in v1.19.0 

type Uintptr struct {
	// contains filtered or unexported fields
}

Uintptrはアトミックなuintptrです。ゼロ値はゼロです。

Uintptrは最初に使用した後でコピーしてはいけません。

func (*Uintptr) Add added in v1.19.0 

func (x *Uintptr) Add(delta uintptr) (new uintptr)

Addはアトミックにdeltaをxに加え、新しい値を返します。

func (*Uintptr) And added in v1.23.0 

func (x *Uintptr) And(mask uintptr) (old uintptr)

Andは、提供されたマスクとしてビットマスクを使用してx上でビット単位のAND操作をアトミックに実行し、 古い値を返します。

func (*Uintptr) CompareAndSwap added in v1.19.0 

func (x *Uintptr) CompareAndSwap(old, new uintptr) (swapped bool)

CompareAndSwapは、xの比較交換操作を実行します。

func (*Uintptr) Load added in v1.19.0 

func (x *Uintptr) Load() uintptr

Loadはアトミックにxに格納されている値をロードして返します。

func (*Uintptr) Or added in v1.23.0 

func (x *Uintptr) Or(mask uintptr) (old uintptr)

Orは、提供されたマスクとしてビットマスクを使用してx上でビット単位のOR操作をアトミックに実行し、 古い値を返します。

func (*Uintptr) Store added in v1.19.0 

func (x *Uintptr) Store(val uintptr)

Storeはアトミックにvalをxに格納します。

func (*Uintptr) Swap added in v1.19.0 

func (x *Uintptr) Swap(new uintptr) (old uintptr)

Swapはアトミックにnewをxに格納し、前の値を返します。

type Value added in v1.4.0 

type Value struct {
	// contains filtered or unexported fields
}

Valueは、一貫した型の値のアトミックなロードとストアを提供します。 Valueのゼロ値は Value.Load からnilを返します。 Value.Store が呼び出された後、Valueはコピーしてはなりません。

最初の使用後、Valueはコピーしてはなりません。

Example (Config)

次の例は、Valueを使用して定期的なプログラム設定の更新と 変更のワーカーゴルーチンへの伝播を行う方法を示しています。 

var config atomic.Value // 現在のサーバー設定を保持します
// 初期設定値を作成し、configに格納します。
config.Store(loadConfig())
go func() {
	// 10秒ごとに設定を再読み込みし、
	// 新しいバージョンで設定値を更新します。
	for {
		time.Sleep(10 * time.Second)
		config.Store(loadConfig())
	}
}()
// 最新の設定値を使用して受信リクエストを処理する
// ワーカーゴルーチンを作成します。
for i := 0; i < 10; i++ {
	go func() {
		for r := range requests() {
			c := config.Load()
			// 設定cを使用してリクエストrを処理します。
			_, _ = r, c
		}
	}()
}
Example (ReadMostly)

次の例は、コピーオンライトのイディオムを使用して、 頻繁に読み取られるが、あまり更新されないデータ構造を維持する方法を示しています。 

package main

import (
	"github.com/shogo82148/std/sync"
	"github.com/shogo82148/std/sync/atomic"
)

func main() {
	type Map map[string]string
	var m atomic.Value
	m.Store(make(Map))
	var mu sync.Mutex // 書き込み者のみが使用します
	// read関数は、さらなる同期化なしでデータを読み取るために使用できます
	read := func(key string) (val string) {
		m1 := m.Load().(Map)
		return m1[key]
	}
	// insert関数は、さらなる同期化なしでデータを更新するために使用できます
	insert := func(key, val string) {
		mu.Lock() // 他の潜在的な書き込み者と同期します
		defer mu.Unlock()
		m1 := m.Load().(Map) // データ構造の現在の値をロードします
		m2 := make(Map)      // 新しい値を作成します
		for k, v := range m1 {
			m2[k] = v // 現在のオブジェクトから新しいオブジェクトにすべてのデータをコピーします
		}
		m2[key] = val // 必要な更新を行います
		m.Store(m2)   // 現在のオブジェクトを新しいオブジェクトとアトミックに置き換えます
		// この時点で、すべての新しい読み取り者は新しいバージョンで作業を開始します。
		// 既存の読み取り者（もしあれば）がそれを使用し終えると、古いバージョンはガベージコレクションされます。
	}
	_, _ = read, insert
}

func (*Value) CompareAndSwap added in v1.17.0 

func (v *Value) CompareAndSwap(old, new any) (swapped bool)

CompareAndSwapは、Value の比較交換操作を実行します。

与えられたValueに対するCompareAndSwapのすべての呼び出しは、同じ具体的な型の値を使用しなければなりません。 不一致の型をCompareAndSwapするとパニックを引き起こし、CompareAndSwap(old, nil)も同様です。

func (*Value) Load added in v1.4.0 

func (v *Value) Load() (val any)

Loadは、最も最近のStoreによって設定された値を返します。 このValueに対してStoreの呼び出しがない場合、nilを返します。

func (*Value) Store added in v1.4.0 

func (v *Value) Store(val any)

Storeは、Value vの値をvalに設定します。 与えられたValueに対するStoreのすべての呼び出しは、同じ具体的な型の値を使用しなければなりません。 不一致の型をStoreするとパニックを引き起こし、Store(nil)も同様です。

func (*Value) Swap added in v1.17.0 

func (v *Value) Swap(new any) (old any)

Swapは新しい値をValueに格納し、前の値を返します。Valueが空の場合はnilを返します。

与えられたValueに対するSwapのすべての呼び出しは、同じ具体的な型の値を使用しなければなりません。 不一致の型をSwapするとパニックを引き起こし、Swap(nil)も同様です。

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.