go并发编程有哪些方式

Go语言的并发编程主要依赖于其内置的并发特性，包括但不限于以下几种方式：

1. **Go Routines**：Go语言中最基本的并发单元是Go Routine。Go Routine类似于轻量级的线程，它允许你并行执行函数。创建Go Routine非常简单，只需在函数调用前加上关键字`go`即可。

   ```go
   go myFunction()
   ```

2. **Channels**：Channels是Go语言中用于在不同的Go Routine之间进行通信的管道。它们可以用来安全地在并发执行的Go Routine之间传递数据。

   ```go
   ch := make(chan int)
   go func(ch chan<- int) { ch <- 1 }(ch)
   ```

3. **WaitGroup**：WaitGroup用于等待一组并发操作完成。它通过计数来跟踪仍在运行的Go Routine数量，直到所有Go Routine都完成，计数器才会归零。

   ```go
   var wg sync.WaitGroup
   wg.Add(1)
   go func() {
       defer wg.Done()
       // 并发执行的代码
   }()
   wg.Wait()
   ```

4. **Mutexes**：Mutex（互斥锁）用于保护共享资源不被多个Go Routine同时修改。它确保了在任何给定时间，只有一个Go Routine可以执行临界区的代码。

   ```go
   var mu sync.Mutex
   mu.Lock()
   defer mu.Unlock()
   // 临界区
   ```

5. **Atomic Operations**：Go语言提供了一组原子操作函数，用于在不使用互斥锁的情况下，对共享资源进行安全的并发访问。

   ```go
   var counter int32 = 0
   for i := 0; i < 100; i++ {
       go func() {
           for j := 0; j < 100; j++ {
               atomic.AddInt32(&counter, 1)
           }
       }()
   }
   ```

6. **Context**：Context用于在并发运行的Go Routine之间传递请求范围的值，如取消信号、截止时间、生命周期等。

   ```go
   ctx, cancel := context.WithCancel(context.Background())
   defer cancel()
   go func(ctx context.Context) {
       select {
       case <-ctx.Done():
           return
       // 其他并发操作
       }
   }(ctx)
   ```

7. **Select and Case**：Select语句用于监听多个Channels，当其中一个Channel准备好进行通信时，执行相应的Case。

   ```go
   for {
       select {
       case data := <-dataChannel:
           // 使用data
       case <-quitChannel:
           return
       }
   }
   ```

8. **Sync Pools**：Sync.Pool提供了一个可以存储和复用临时对象的池子，以减少内存分配和垃圾收集的压力。

   ```go
   pool := sync.Pool{
       New: func() interface{} {
           return new(MyType)
       },
   }
   obj := pool.Get().(*MyType)
   defer pool.Put(obj)
   ```

9. **Tickers**：Ticker用于周期性地执行任务。它在指定的时间间隔后发送时间到Channel。

   ```go
   ticker := time.NewTicker(time.Second)
   defer ticker.Stop()
   for range ticker.C {
       // 每秒执行的代码
   }
   ```

10. **Once**：sync.Once类型用于执行一次性的初始化或其他只需执行一次的操作。

    ```go
    var once sync.Once
    once.Do(initFn)
    ```

这些是Go语言中并发编程的一些基本和常用的方式。Go语言的并发模型旨在简单、高效，并且易于理解，使得开发者能够轻松地编写并发程序。