GoLang是怎么做到并发的

Go 语言通过内置的 Goroutine 和 Channel 实现高效并发。这是 Go 的核心特性之一，下面我从原理和机制两个角度帮你详细解释：

💡 一、Goroutine：轻量级线程

✅ 什么是 Goroutine？

Goroutine 是 Go 语言中的 轻量级线程，由 Go 运行时（runtime）管理，而不是操作系统。

你只需要使用 go 关键字调用一个函数，就可以创建一个新的 Goroutine：

go myFunction()

✅ 它有多轻量？

• 一个 Goroutine 的初始栈大小仅约 2KB（可动态增长）。
• 同一进程中可轻松创建 数万个 Goroutine，而不会像线程那样消耗大量内存。

✅ 与线程的区别：

🔁 二、Go 调度器：GPM 模型

Go 的并发运行依赖调度器，它采用了 GPM 模型（Goroutine, Processor, Machine）：

• G：Goroutine（任务）
• P：Processor（逻辑处理器，数量等于可并行执行的线程数）
• M：Machine（绑定线程，实际在操作系统层运行）

调度过程简要：

1. Goroutine 被创建并进入 G 队列。
2. 调度器从 G 队列中取出一个 G，并分配给一个 P。
3. P 会找一个空闲的 M（系统线程）来运行这个 G。
4. 如果当前 G 阻塞（例如网络 IO），该 M 会被重新用于其他 G。

这种机制确保了 高效协作调度，最大化 CPU 使用率。

🔗 三、Channel：通信机制

Go 提供 Channel 作为 Goroutine 之间通信的工具，实现 CSP（通信顺序进程）并发模型。

ch := make(chan int)

go func() {
    ch <- 10 // 发送数据
}()

data := <-ch // 接收数据
fmt.Println(data)

✅ 特性：

• Channel 可 同步 或 异步缓冲。
• Channel 保证 线程安全，不需要加锁。
• 配合 select 实现 多路复用。

🧠 四、Go 并发优势总结

✅ 示例：同时爬多个网页

func fetch(url string, ch chan string) {
    // 模拟爬取
    time.Sleep(1 * time.Second)
    ch <- fmt.Sprintf("Fetched %s", url)
}

func main() {
    urls := []string{"a.com", "b.com", "c.com"}
    ch := make(chan string)
    for _, url := range urls {
        go fetch(url, ch)
    }
    for range urls {
        fmt.Println(<-ch)
    }
}

在 Go 语言中，“进程、线程、协程”的概念和调度关系有一套独特的模型，核心是 Go Runtime 的调度器，也就是我们常说的 GPM 模型（Goroutine-Processor-Machine）。

🧱 一、GPM基本定义

🔁 二、GPM 模型详解（Goroutine - Processor - Machine）

Go runtime 使用 GPM 三个组件来管理并发：

📌 它们的关系图（概念图）：

     Goroutines (G) ---+
                       |
                       v
     Processor (P) ----> Goroutine队列
                       |
                       v
     Machine (M) ------> 调度执行 G

🔄 三、调度流程说明（简化流程）

1. 启动阶段：

   • Go 程序启动时，Go runtime 会创建多个 M（线程）和 P（处理器）。
   • 默认 P 的数量是 runtime.GOMAXPROCS() 的值（默认等于 CPU 核心数）。

2. 执行阶段：

   • G（Goroutine）创建后，会被放入某个 P 的本地队列。
   • P 负责从队列中挑一个 G 出来运行。
   • P 找一个空闲的 M（操作系统线程）去执行这个 G。

3. 阻塞处理：

   • 如果某个 G 阻塞（比如系统调用），M 也就阻塞了，但 P 不会等待，会切换新的 M 继续调度其他 G。
   • 避免了传统线程模型中阻塞导致线程资源浪费的问题。

4. 偷取机制（Work Stealing）：

   • 某个 P 没有 G 运行时，会去其他 P 的队列里“偷”任务，保证 CPU 利用率。

💡 四、总结对比

📚 五、例子说明调度

func task(id int) {
    fmt.Printf("Goroutine %d start\n", id)
    time.Sleep(time.Second)
    fmt.Printf("Goroutine %d end\n", id)
}

func main() {
    for i := 0; i < 10; i++ {
        go task(i)
    }
    time.Sleep(2 * time.Second)
}

• 上面代码创建了 10 个 Goroutine。
• Go 会用少数几个线程（M）+ 若干个逻辑 P，把这些 Goroutine 自动调度执行完。
• 程序员无需关注线程的创建、销毁或调度逻辑。

🔍 Bonus：GOMAXPROCS 的意义

你可以通过 runtime.GOMAXPROCS(N) 设置并发使用的 CPU 核数，也就是最多有几个 P 在调度 G。

runtime.GOMAXPROCS(runtime.NumCPU())

怎么做到非阻塞的，比如监听套接字，读写文件，read write

Go 语言之所以能够实现 非阻塞 的并发编程，关键在于 Go runtime 自己实现了一套调度器和 IO 多路复用机制，屏蔽了操作系统底层阻塞的复杂性。以下是它背后的原理 👇

🧠 一、Go 的“非阻塞”不是你想的“非阻塞”

Go 中调用 net.Conn.Read()、os.File.Read() 这些接口在代码层面看是阻塞的，但底层实现为你做了“魔法”——即：

表面上是同步阻塞，实际上是异步非阻塞 + 协程挂起 + 调度恢复。

你不需要写回调，也不用关心 epoll/kqueue，一切由 Go runtime 完成 ✅

🔍 二、底层原理：Go Runtime + epoll/kqueue + 协程切换

1️⃣ 网络 IO：基于 epoll（Linux）/ kqueue（BSD/macOS）

Go 的网络库使用 非阻塞套接字 + epoll/kqueue/IOCP + runtime poller

流程如下：

1. Read() 时，如果数据不可读：

   • 把该 Goroutine 挂起（G→阻塞态）。
   • 通过 epoll_wait 等待套接字可读。
   • 当数据到达，唤醒 Goroutine，由调度器重新运行。

2. 整个过程中：

   • 不会阻塞线程 M
   • 不会浪费 CPU
   • 只暂停这个 Goroutine，其他 Goroutine 照常运行

👉 底层通过 runtime/netpoll 模块实现 IO 多路复用机制。

2️⃣ 文件 IO：平台相关（非完美）

文件 IO 在不同平台行为不一样：

✅ Linux下的策略（最常见）：

• Go 在内部维护一个 async IO 线程池。

• 当你对文件使用 Read()：

  • 如果是普通文件（阻塞），Go 将它交给后台线程池处理。
  • 当前 Goroutine 会挂起，避免主线程 M 被阻塞。

🧩 三、read/write 系统调用是怎么处理的？

假如你调用：

conn.Read(buf)

实际上 Go 会：

1. 将连接设置为非阻塞（fcntl(fd, F_SETFL, O_NONBLOCK)）

2. 尝试调用 read()：

   • 如果能读，直接返回。

   • 如果返回 EAGAIN 或 EWOULDBLOCK：

     • 将 fd 注册到 epoll_wait 中。
     • 挂起当前 Goroutine。
     • 等待内核通知有数据。
     • 恢复 Goroutine → 再次尝试读。

Go 的这一机制叫做 网络调度器（netpoller）。

🧪 四、关键模块：Go源码模块介绍

你可以看到 runtime/internal/netpoll 模块中有 epoll 的实现逻辑。

✅ 五、总结：Go 如何实现非阻塞 IO？

📌 举个例子：socket 读写协程挂起

conn, _ := net.Dial("tcp", "example.com:80")

go func() {
    buf := make([]byte, 1024)
    n, err := conn.Read(buf) // 如果不可读，会挂起当前 goroutine
    if err == nil {
        fmt.Println("收到数据:", string(buf[:n]))
    }
}()

这个 Read() 会在数据还没到达时自动让出 CPU，挂起当前 goroutine，等待数据可读再恢复，整个过程无需你自己写 epoll。

• netpoll 与 epoll_fd 配合
• 文件 IO 的线程池
• syscall 封装成协程友好的形式

GO在Linux系统中使用了epoll

Go 在 Linux 系统上底层确实使用了 epoll 来实现网络 IO 的非阻塞调度

是的，✅ Go 在 Linux 系统上底层确实使用了 epoll 来实现网络 IO 的非阻塞调度。

这是 Go 实现高效网络并发（尤其是成千上万个 Goroutine 同时进行网络通信）的核心机制之一。

🔍 一、Go 使用 epoll 的位置

在 Linux 下，Go 的网络 IO 使用的是：

• epoll_create1 创建 epoll fd
• epoll_ctl 注册文件描述符
• epoll_wait 等待事件到来

这些都是在 Go 的 runtime/netpoll 模块中实现的（Go 源码层面）。

📁 二、源码证据

Go 的源码在以下几个文件中直接或间接使用了 epoll：

• src/runtime/netpoll_epoll.go：epoll 封装实现
• src/runtime/netpoll.go：统一的 netpoll 接口（跨平台）
• src/runtime/netpoll_linux.go：特定于 Linux 的实现

示例：epoll 初始化（Go runtime）

func netpollinit() {
    epfd = epollcreate1(_EPOLL_CLOEXEC)
    ...
}

func netpoll(waitfull bool) {
    var events [128]epollevent
    n := epollwait(epfd, &events[0], int32(len(events)), timeout)
    ...
}

这说明：

• Go 启动时初始化了一个全局的 epoll 实例。
• 所有网络 FD（如 net.Conn）都注册在这个 epoll 上。
• 当 Goroutine 进行网络读写时，如果数据不可用，它会挂起，并交由 epoll 监控。
• 一旦事件到来（如“可读”），runtime 会唤醒相应的 Goroutine。

🧠 三、配合非阻塞 FD 使用

Go 还会把套接字设置为 非阻塞模式：

syscall.SetNonblock(fd, true)

然后配合 epoll 的 EPOLLIN, EPOLLOUT 等事件来判断何时能继续 read/write。

📦 四、哪些 Go 包用到了它？

你常用的这些包其实都是底层套了一层 epoll：

📌 五、为什么自己用 netpoll 的人不多？

因为：

• Go 封装得太好了（对程序员是同步阻塞式接口）
• 你写 conn.Read() 就已经间接用到 epoll，无需自己写 epoll 代码
• 类似 Java NIO 需要你自己注册 selector，而 Go 直接帮你做了这一步

✅ 总结

如果你想深入查看源码里具体的 epoll 创建、事件监听、Goroutine 唤醒过程，我也可以带你按行分析 runtime/netpoll_epoll.go。是否继续？🧐