type Data struct {
    x int64 // 线程A更新的变量
    y int64 // 线程B更新的变量
}

type Data struct {
    x int64           // 线程A更新的变量
    _ [7]int64        // 填充7个int64以对齐至64字节的cache line大小
    y int64           // 线程B更新的变量
}

package main
import (
	"testing"
)
// NonAlignedStruct 未对齐的结构体，补充后占24个字节
type NonAlignedStruct struct {
	a byte // 1字节,补齐7字节
	b int64 // 8字节
	c byte // 1字节,补齐7字节
}
// AlignedStruct 已对齐的结构体，补充后占16个字节
type AlignedStruct struct {
	b int64 // 8字节
	a byte // 1字节
	c byte // 1字节
	_ [6]byte // 填充6个字节，总共16个字节
}
const arraySize = 1024 * 1024
var (
	nonAlignedArray [arraySize]NonAlignedStruct
	alignedArray    [arraySize]AlignedStruct
	result          int64
)
// 初始化数组
func init() {
	for i := 0; i < arraySize; i++ {
		nonAlignedArray[i] = NonAlignedStruct{
			a: byte(i),
			b: int64(i),
			c: byte(i),
		}
		alignedArray[i] = AlignedStruct{
			a: byte(i),
			b: int64(i),
			c: byte(i),
		}
	}
}
// BenchmarkNonAligned 测试未对齐结构体的性能
func BenchmarkNonAligned(b *testing.B) {
	var sum int64
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		for j := 0; j < arraySize; j++ {
			sum += nonAlignedArray[j].b // 读取未对齐结构体的字段
		}
	}
	result = sum // 防止编译器优化
}
// BenchmarkAligned 测试已对齐结构体的性能
func BenchmarkAligned(b *testing.B) {
	var sum int64
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		for j := 0; j < arraySize; j++ {
			sum += alignedArray[j].b // 读取已对齐结构体的字段
		}
	}
	result = sum // 防止编译器优化
}

// CacheLinePad 用来填充结构体，避免伪共享
type CacheLinePad struct{ _ [CacheLinePadSize]byte }
// CacheLineSize 是 CPU 的缓存行大小，不同的 CPU 架构可能不同.
// 目前 Go 运行时没有检测真实的缓存行大小，所以代码实现使用每个 GOARCH 的常量 CacheLinePadSize 作为近似值。
var CacheLineSize uintptr = CacheLinePadSize

// CacheLinePadSize is used to prevent false sharing of cache lines.
// We choose 128 because Apple Silicon, a.k.a. M1, has 128-byte cache line size.
// It doesn't cost much and is much more future-proof.
const CacheLinePadSize = 128

// CacheLinePadSize is used to prevent false sharing of cache lines.
// We choose 64 because Loongson 3A5000 the L1 Dcache is 4-way 256-line 64-byte-per-line.
const CacheLinePadSize = 64

//go:build 386 || amd64
package cpu
const CacheLinePadSize = 64

type CacheLinePad struct{ _ [cacheLineSize]byte }

type semaRoot struct {
	lock  mutex
	treap *sudog        // root of balanced tree of unique waiters.
	nwait atomic.Uint32 // Number of waiters. Read w/o the lock.
}
var semtable semTable
// Prime to not correlate with any user patterns.
const semTabSize = 251
type semTable [semTabSize]struct {
	root semaRoot
	pad  [cpu.CacheLinePadSize - unsafe.Sizeof(semaRoot{})]byte
}

type mheap struct {
	_ sys.NotInHeap
	lock mutex
	pages pageAlloc // page allocation data structure
	sweepgen uint32 // sweep generation, see comment in mspan; written during STW
	allspans []*mspan // all spans out there
	pagesInUse         atomic.Uintptr // pages of spans in stats mSpanInUse
	pagesSwept         atomic.Uint64  // pages swept this cycle
	pagesSweptBasis    atomic.Uint64  // pagesSwept to use as the origin of the sweep ratio
	sweepHeapLiveBasis uint64         // value of gcController.heapLive to use as the origin of sweep ratio; written with lock, read without
	sweepPagesPerByte  float64        // proportional sweep ratio; written with lock, read without
	reclaimIndex atomic.Uint64
	reclaimCredit atomic.Uintptr
	_ cpu.CacheLinePad // prevents false-sharing between arenas and preceding variables
	
	arenas [1 << arenaL1Bits]*[1 << arenaL2Bits]*heapArena
    ...
}

var stackpool [_NumStackOrders]struct {
	item stackpoolItem
	_    [(cpu.CacheLinePadSize - unsafe.Sizeof(stackpoolItem{})%cpu.CacheLinePadSize) % cpu.CacheLinePadSize]byte
}