Golang基础-基础类型哪些是线程安全？

在 Go 中，是否线程安全（即是否能够在多个 goroutine 之间并发访问时不引发数据竞争）与数据结构本身的设计和使用方式密切相关。Go 提供了很多内建类型和标准库中的数据结构，它们在并发访问时的行为有所不同。我们可以从 Go 内建类型和常见数据结构中进行分类，分为 线程安全 和 线程不安全 两类。

线程安全类型（并发安全）

1. sync.Mutex 和 sync.RWMutex：

   • 这些是用于显式同步的原语，能够保护其他类型在多 goroutine 环境中的并发访问。sync.Mutex 用于互斥锁，sync.RWMutex 用于读写锁，能够在并发环境下保证线程安全。

   • 使用场景：如果你希望确保对某个共享资源的访问是串行化的，可以使用这些锁来同步对资源的访问。

2. sync/atomic 包：

   • Go 提供的 sync/atomic 包中的原子操作，可以用来进行无锁的线程安全操作。这些操作能够保证数据在并发访问时不会出现数据竞争，且效率较高。

   • 常用类型

     ：

     • atomic.Int32, atomic.Int64

     • atomic.Uint32, atomic.Uint64

     • atomic.Value

     • atomic.AddInt32、atomic.CompareAndSwapInt32 等

   • 使用场景：如果需要对一个基本类型（如整数）进行原子操作而不使用锁，atomic 是理想的选择。

3. channel 类型：

   • Go 的 channel 本身是 线程安全 的，多个 goroutine 可以同时发送和接收数据，只要每个 channel 操作（发送或接收）本身是单独的操作。channel 内部的同步机制确保了线程安全。

   • 注意事项：channel 是线程安全的，但如果你在多个 goroutine 中并发读写同一个 channel（例如通过 select），就需要确保对 channel 的操作是有序的，避免死锁。

4. sync.Map：

   • sync.Map 是 Go 1.9 引入的一个并发安全的 map 实现，它提供了并发读写的支持。

   • 适用于多 goroutine 环境中需要频繁读写数据的场景，不同于传统的 map 类型，sync.Map 是为并发访问设计的。

   • 使用场景：适用于频繁读写的场景，尤其是在没有特别复杂的并发读写策略时。

5. time.Timer 和 time.Ticker：

   • 这些是 Go 标准库中的定时器类型，它们可以在多个 goroutine 中安全使用。它们内部实现了必要的同步机制，确保并发访问时不出现问题。

线程不安全类型（并发不安全）

1. map 类型：

   • Go 的内建 map 类型 本身不是线程安全的。如果多个 goroutine 同时读取和写入同一个 map，会引发数据竞争和不可预测的行为。

   • 如果要在并发场景下使用 map，需要显式的同步机制（如使用 sync.Mutex）来保护访问。

   • 注意：对于 map 类型，你可以使用 sync.Map 来替代，它是线程安全的。

2. slice 类型：

   • Go 的 slice 本身不是线程安全的。在并发环境下，如果多个 goroutine 访问同一个 slice，并且至少有一个 goroutine 对其进行修改（如修改其元素或扩容），则需要显式的同步控制。

   • 如果对 slice 进行并发读操作并且没有修改操作，通常是安全的。但如果并发修改，可能会导致数据竞争。

3. string 类型：

   • string 本身是不可变的（即一旦创建就不能被修改），因此多个 goroutine 并发读取 string 是线程安全的。但是，string 类型的并发修改（例如通过 []byte 转换后修改其内容）是不安全的。

   • 如果只是并发读取 string，则可以认为它是线程安全的。

4. array 类型：

   • 和 slice 类似，Go 中的 array 类型本身是线程不安全的，特别是在并发修改时。你需要显式的同步来确保多 goroutine 环境下对 array 的并发访问不会发生问题。

5. 自定义结构体类型：

   • 自定义结构体（包括其字段）默认是线程不安全的，除非你自己显式地加锁或者使用其它同步机制来确保线程安全。

   • 常见做法：为结构体添加 sync.Mutex 或使用 atomic 操作，确保字段之间的线程安全。

6. os.File 和其他 I/O 操作对象：

   • 文件操作 (os.File) 和其他 I/O 操作对象（如数据库连接、网络连接等）通常都不是线程安全的，需要确保对这些资源的访问是同步的，避免并发访问时产生问题。

总结

• 线程安全的类型：sync.Mutex、sync.RWMutex、sync.Map、channel、atomic 包中的原子操作类型、time.Timer 和 time.Ticker 等。

• 线程不安全的类型：map、slice、array、自定义结构体类型、os.File 等。

提高并发安全性的方法

1. 显式加锁：

   • 使用 sync.Mutex 或 sync.RWMutex 来保护并发访问的资源。

2. 原子操作：

   • 使用 sync/atomic 包提供的原子操作（如 atomic.AddInt32、atomic.CompareAndSwapInt32 等）来保证对共享资源的线程安全访问。

3. 并发安全的数据结构：

   • 使用 sync.Map 等并发安全的数据结构，避免手动管理同步。

4. 限制并发读写：

   • 在并发环境中，如果你需要读写共享资源，尽量避免直接在 map 和 slice 上进行并发操作，改为使用合适的同步工具（如加锁或使用 sync.Map）。

了解这些可以帮助你更好地在 Go 中处理并发和同步，避免因并发访问导致的数据竞争和程序错误。