Golang中[]byte的单个字节访问是否并发安全？

Golang中[]byte的单个字节访问是否并发安全？ 我正在尝试理解对 []byte 中字节进行原子访问的限制。

我在下面的代码中模拟了以下场景：

1. 我有一个 []byte 数据缓冲区，其中每个字节的低半字节是一个所有者ID，显然范围是 0 到 15。
2. 我有 16 个 goroutine，ID 为 0 到 15。假设每个 goroutine 拥有那些低半字节等于其 ID 的字节。
3. 这些 goroutine 持续且并发地扫描所有数据以寻找属于它们的字节，当找到一个时，它们会更改缓冲区中该字节的高半字节。

重要的是，15 个 goroutine 可以并发访问同一个字节，而一个 goroutine 可以向该字节写入，但由于有且仅有一个 goroutine 会写入给定的字节，所以不存在竞态条件。我相信，这只是原子加载和设置的问题。

在 16+ 核的 AMD x64 硬件（包括 Ryzen 和 Threadripper）上长时间运行似乎没有问题。如果这确实有效，将为我们节省巨大的同步开销。

这实际上是安全的吗？还是依赖于硬件？或者我只是在这次测试中运气好？

package main

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

func changeMyData(myID byte, data []byte, running *int64, wg *sync.WaitGroup) {
	// each worker will only change bytes that match
	// their id in the low order nibble
	var passNum byte
	for {

		// All workers are concurrently reading all of data, and all workers
		// are concurrently writing to data, but just to the bytes they own.
		for i, b := range data {
			// if id is in the low order nibble, then this byte is owned by this routine.
			if b&0x0F == myID {
				// put passNum in the high order nibble and myID back in the low
				data[i] = passNum<<4 | myID
			}
		}

		// we only check for a stop between complete passes through the data
		// so all all bytes with this id have the same passNum in the high nibble.
		if atomic.LoadInt64(running) == 0 {
			wg.Done()
			return
		}
		passNum++
	}
}

func main() {
	// Make the length shorter (min 32) to increse the velocity of changes at every byte.
	// Make longer to have a better chance catching write errors with wrong passNum.
	data := make([]byte, 64)
	var id byte

	for i := range data {
		data[i] = byte(i & 0x0F) // just set the low order nibble to incrementing 0-15
	}

	// turn on the running flag
	running := new(int64)
	*running = 1
	var wg sync.WaitGroup

	for id = 0; id < 0x0F; id++ {
		wg.Add(1)
		go changeMyData(id, data, running, &wg)
	}

	// Make this longer to increase the chance of a conflict
	time.Sleep(10 * time.Second)
	atomic.StoreInt64(running, 0)

	// Wait for the workers to finish
	wg.Wait()

	// Now make sure the data is what we expect...

	// make sure the low order nibble is still correct for every byte.
	for bNum, b := range data {
		// expected low order nibble
		id = b & 0x0F
		if byte(bNum&0x0F) != id {
			fmt.Printf("Error: owning ID of bNum %v=%X changed to %X\n", bNum, bNum, id)
		}
	}

	// make sure the high order nibble is the same for every byte owned by a given id.
	// This just means all bytes for an id are the same: same high and same low nibble.
	for id = 0; id < 0x0F; id++ {
		expectedByte := data[int(id)]

		// loop over each byte owned by this id.
		for bNum := int(id); bNum < len(data); bNum += 0x10 {
			if data[bNum] != expectedByte {
				fmt.Printf("Error: byte at bNum=%X got %X but expected %X\n", bNum, data[bNum], expectedByte)
			}
		}
	}

	fmt.Printf("ByteNum:")
	for bNum, _ := range data {
		fmt.Printf("%3X", bNum)
	}

	fmt.Printf("\n  Value:")
	for _, b := range data {
		fmt.Printf("%3X", b)
	}
	fmt.Println()

}