语言最核心、最亮眼的特性，Go

从语言层面原生支持并发，不像

等语言需要依赖线程库、协程框架，它的并发设计简洁、轻量、高效，也是

能在后端开发

并发的核心思想：不要通过共享内存来通信，要通过通信来共享内存

这是

语言之父

并发设计的底层逻辑：

• 传统语言（Java/C++）并发：多线程抢占共享内存，通过

  锁(synchronized/lock)

  保证数据安全，容易出现死锁、竞态、锁争用等问题；

• Go

  语言并发：goroutine

  之间不推荐共享内存，而是通过专门的

  channel

  转移到另一个，天然避免数据竞争，代码更安全、简洁。

二、Go

的并发能力完全依赖两个核心组件实现，二者相辅相成，缺一不可：goroutine（协程）

channel（通道）

1.

Goroutine

Goroutine

goroutine

语言内置的、轻量级的执行单元，也叫「用户级线程

协程」，它由

调度，而不是操作系统内核调度。

（2）Goroutine

核心特点

• 极致轻量：一个

  goroutine

  2KB，并且栈空间可以动态扩容

  缩容（最大几

  自动管理；

• 资源占用极少：一台普通服务器上，轻松创建

  goroutine，不会有内存压力；而操作系统线程（thread）的栈空间默认是

  1MB，创建几千个线程就会内存溢出；

• 调度效率极高：Go

  M/P/G

  高效映射到操作系统线程，调度切换的开销只有线程的几百分之一；

• goroutine

  goroutine

  Goroutine

  语法超级简单：在函数调用前加一个

  go

  注意：主goroutine执行完会直接退出，导致子goroutine来不及执行//

  这里简单休眠1秒，等子goroutine执行完毕（仅演示，生产不用这个方式）fmt.Println("主协程开始等待...")import

  "time"

  实际代码要把import写在顶部time.Sleep(time.Second)fmt.Println("主协程执行结束")

  }

  并发调度）：

  主协程开始等待...

  协程[goroutine-1]：输出数字

  3

  主协程执行结束

  （4）补充：主

  main()

  goroutine）创建；

• 主

  goroutine

  都会被强制终止（不管是否执行完）。

2.

Channel

Channel

channel

语言提供的原生同步通信机制，可以理解为「goroutine

goroutine

的并发思想：通过通信来共享内存。

（2）Channel

核心特点

1. 通道是类型安全的：声明通道时必须指定传递的数据类型，只能传递对应类型的数据；
2. 通道是阻塞特性的（核心）：
   • 向一个通道发送数据ch

     <-

     从通道取走数据；

   • 从一个通道接收数据data

     <-ch

     协作的核心原理；

3. 通道可以手动关闭，关闭后无法再发送数据，只能接收剩余数据；
4. 通道天然解决「数据竞争」：goroutine

   goroutine

   有缓冲通道，通过「缓冲区大小」区分，默认是

   0，声明时可以省略第二个参数：make(chan

   int)

   • 特性：发送和接收必须同时就绪，否则会阻塞；
   • 本质：实现

     goroutine

     之间的严格同步，发送方发数据的瞬间，必须有接收方在取数据，相当于

     “一手交钱、一手交货”；

   • 适用场景：goroutine

     发送数据，无缓冲通道会阻塞，直到有goroutine接收fmt.Println("数据发送成功")

     func

     主goroutine接收数据，此时sendData的阻塞才会解除data

     <-chfmt.Printf("主协程接收数据：%d\n",

     data)

     数据的通道

     • 特性：发送数据时，只要缓冲区没满，发送方不会阻塞；只有缓冲区满了，发送方才会阻塞；接收数据时，只有缓冲区空了，接收方才会阻塞；
     • 本质：实现

       goroutine

       之间的异步通信，可以暂存数据，不用严格同步；

     • 适用场景：需要缓存数据、削峰填谷的并发场景。

     "goroutine"fmt.Println("两个数据发送成功，缓冲区已满")//

     接收一个数据，缓冲区剩余1个fmt.Println("接收数据：",

     <-ch)//

     执行结果：

     两个数据发送成功，

     缓冲区已满

     接收数据：

     hello

     接收数据：

     channel

     （4）Channel

     的关闭与遍历

     • 关闭通道：close(ch)，只能由发送方关闭，接收方关闭会

       panic；

     • 判断通道是否关闭：接收数据时可以用

       data,

       ch，会自动遍历通道的所有数据，通道关闭后自动退出循环。

     执行完毕，这是极不推荐的写法（睡眠时间无法精准控制）。

     Go

     sync

     WaitGroup，专门用来等待一组

     goroutine

     核心方法

     1. wg.Add(n)：设置需要等待的

        goroutine

        的个数；

     2. wg.Done()：每个

        goroutine

        wg.Add(-1)，表示完成一个；

     3. wg.Wait()：主

        goroutine

        阻塞等待所有任务完成fmt.Println("所有goroutine执行完毕，主协程退出")

        }

        传统多线程并发（核心优势总结）

     很多人会问：Java

     也有线程、Python

     src="https://i-blog.csdnimg.cn/direct/d63fdca83a474b989f4a7f47c72d160c.png"

     width="677">

     核心结论：Go

     “锦上添花”，而是语言层面的降维打击，它让并发编程的门槛大幅降低，性能大幅提升，不用关心线程池、锁机制，就能写出高效、安全的并发代码。

     四、Go

     并发的进阶内容（拓展，按需学习）

     这里补充两个进阶知识点，是

     Mutex

     的设计思想是「通信优先于共享」，但极少数场景下，goroutine

     互斥锁保证数据安全。

     • mutex.Lock()：加锁，同一时间只有一个

       goroutine

       能获取锁；

     • mutex.Unlock()：解锁，释放锁资源；
     • 注意：尽量少用锁，锁会带来竞态、死锁风险，能用

       channel

       解决的问题，坚决不用锁。

     2.

     Select

     多路复用通道

     select

     channel

     就绪；

   • 适用场景：同时处理多个通道、设置通道超时、非阻塞读写通道等。

   总结

   1. Go

      并发的核心思想：不要通过共享内存来通信，要通过通信来共享内存；

   2. Go

      并发的两大基石：goroutine（轻量级协程，并发执行体）

      channel（通道，协程间通信方式）；

   3. Goroutine：轻量（2KB

      栈）、高效、百万级创建，runtime

      调度，主协程退出则程序结束；

   4. Channel：类型安全、阻塞特性，分无缓冲（同步）和有缓冲（异步），是

      goroutine

      sync.WaitGroup，禁止用

      time.Sleep；

   5. Go

      并发的核心优势：相比传统多线程，资源占用更少、调度更快、代码更简洁、数据更安全；

   6. 进阶兜底：必须共享变量时用

      sync.Mutex，多路通道控制用

      select。