Go Goroutine与线程的本质区分
2021-09-283.9k 阅读
Go Goroutine 概述
在 Go 语言中，Goroutine 是一种轻量级的并发执行单元。与传统的线程不同，Goroutine 旨在提供一种更高效、更易于管理的并发编程模型。一个 Go 程序可以轻松创建数以千计甚至更多的 Goroutine，而不会像创建大量传统线程那样面临资源耗尽的问题。
从语法角度来看，创建一个 Goroutine 非常简单。通过 go 关键字即可启动一个新的 Goroutine 来执行一个函数。例如：
package main
import (
"fmt"
"time"
)
func printNumbers() {
for i := 1; i <= 5; i++ {
fmt.Println("Number:", i)
time.Sleep(time.Millisecond * 200)
}
}
func printLetters() {
for i := 'a'; i <= 'e'; i++ {
fmt.Println("Letter:", string(i))
time.Sleep(time.Millisecond * 300)
}
}
func main() {
go printNumbers()
go printLetters()
time.Sleep(time.Second * 2)
}
在上述代码中，go printNumbers() 和 go printLetters() 分别启动了两个 Goroutine 来并发执行 printNumbers 和 printLetters 函数。主函数中最后通过 time.Sleep 等待一段时间，以确保两个 Goroutine 有足够的时间执行完毕。
线程概述
线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一个进程可以包含多个线程，这些线程共享进程的资源，如内存空间、文件描述符等。
线程由操作系统内核进行调度。当一个线程执行时，它会占用 CPU 时间片。操作系统通过调度算法在不同线程之间切换，以实现多线程并发执行的效果。例如在 C 语言中使用 POSIX 线程库（pthread）创建线程的简单示例：
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
void* printNumbers(void* arg) {
for (int i = 1; i <= 5; i++) {
printf("Number: %d\n", i);
sleep(1);
}
return NULL;
}
void* printLetters(void* arg) {
for (char i = 'a'; i <= 'e'; i++) {
printf("Letter: %c\n", i);
sleep(1);
}
return NULL;
}
int main() {
pthread_t tid1, tid2;
pthread_create(&tid1, NULL, printNumbers, NULL);
pthread_create(&tid2, NULL, printLetters, NULL);
pthread_join(tid1, NULL);
pthread_join(tid2, NULL);
return 0;
}
在这个 C 语言示例中，通过 pthread_create 函数创建了两个线程，分别执行 printNumbers 和 printLetters 函数。pthread_join 函数用于等待线程结束。
本质区分 - 资源占用
- Goroutine 的资源占用
- Goroutine 的栈空间是动态分配的，初始栈空间非常小，一般只有 2KB 左右。随着 Goroutine 的执行，如果需要更多的栈空间，Go 运行时会自动为其分配更多的栈内存，当栈空间不再需要时，也会自动回收。这种动态栈管理机制使得创建大量 Goroutine 时内存占用非常小。
- 例如，假设我们要创建 10000 个 Goroutine：
package main
import (
"fmt"
"time"
)
func simpleGoroutine() {
time.Sleep(time.Millisecond * 100)
}
func main() {
for i := 0; i < 10000; i++ {
go simpleGoroutine()
}
time.Sleep(time.Second)
}
即使创建了这么多 Goroutine，程序也不会因为内存不足而崩溃，因为每个 Goroutine 初始占用的栈空间很小，且动态栈管理机制可以有效控制内存使用。 2. 线程的资源占用
- 传统线程的栈空间在创建时就需要指定大小，一般默认栈大小在数 MB 级别，如在 Linux 系统中，线程默认栈大小通常为 8MB。这意味着创建大量线程时，会消耗大量的内存。
- 以创建 10000 个线程为例，假设每个线程栈大小为 8MB，那么仅仅栈空间就需要 10000 * 8MB = 80GB 的内存，这在大多数系统中是难以承受的，很容易导致系统内存耗尽，程序崩溃。
本质区分 - 调度方式
- Goroutine 的调度
- Goroutine 由 Go 运行时（runtime）进行调度，采用的是 M:N 调度模型。这里的 M 表示操作系统线程，N 表示 Goroutine。Go 运行时维护一个 Goroutine 队列，当一个 Goroutine 被创建时，它会被放入队列中等待调度。
- 运行时会将多个 Goroutine 映射到少量的操作系统线程上执行。例如，在一个多核 CPU 的系统中，Go 运行时可以将不同的 Goroutine 调度到不同的操作系统线程上并行执行，也可以在同一个操作系统线程上通过协作式调度（co - operative scheduling）的方式，在多个 Goroutine 之间切换执行。
- 当一个 Goroutine 执行一个阻塞操作（如 I/O 操作、系统调用、调用
time.Sleep等）时，Go 运行时会自动将该 Goroutine 暂停，并将 CPU 资源分配给其他可运行的 Goroutine，而不需要操作系统内核的介入。这种调度方式避免了线程切换时的上下文切换开销，提高了并发执行的效率。 - 下面通过一个示例来展示 Goroutine 的调度：
package main
import (
"fmt"
"time"
)
func goroutine1() {
for i := 1; i <= 5; i++ {
fmt.Println("Goroutine 1:", i)
time.Sleep(time.Millisecond * 200)
}
}
func goroutine2() {
for i := 1; i <= 5; i++ {
fmt.Println("Goroutine 2:", i)
if i == 3 {
time.Sleep(time.Second)
}
}
}
func main() {
go goroutine1()
go goroutine2()
time.Sleep(time.Second * 3)
}
在这个示例中，goroutine2 在 i == 3 时会执行 time.Sleep(time.Second) 阻塞操作。此时，Go 运行时会暂停 goroutine2，并调度 goroutine1 继续执行，直到 goroutine2 阻塞结束后再继续调度 goroutine2。
2. 线程的调度
- 线程由操作系统内核进行调度，采用的是抢占式调度（pre - emptive scheduling）。操作系统内核通过时间片轮转等调度算法，在不同线程之间分配 CPU 时间片。当一个线程的时间片用完或者被更高优先级的线程抢占时，内核会暂停当前线程的执行，并保存其上下文（包括寄存器状态、栈指针等），然后切换到另一个线程执行。
- 这种抢占式调度方式虽然可以保证每个线程都有机会执行，但上下文切换开销较大。每次上下文切换时，操作系统需要保存和恢复线程的状态信息，这涉及到内存访问和 CPU 寄存器操作，会消耗一定的 CPU 时间。
- 例如，在一个多线程的 C 程序中，当一个线程执行 I/O 操作时，操作系统内核会将该线程阻塞，并将 CPU 资源分配给其他可运行的线程。但这种切换是由内核强制进行的，与线程自身的代码逻辑无关。
本质区分 - 内存模型
- Goroutine 的内存模型
- Goroutine 之间通过通道（channel）进行通信来共享数据，这遵循了“不要通过共享内存来通信，而要通过通信来共享内存”的设计理念。通道是一种类型安全的通信机制，它可以保证数据在不同 Goroutine 之间的传递是线程安全的。
- 例如，下面的代码展示了如何使用通道在两个 Goroutine 之间传递数据：
package main
import (
"fmt"
)
func sender(ch chan int) {
for i := 1; i <= 5; i++ {
ch <- i
}
close(ch)
}
func receiver(ch chan int) {
for num := range ch {
fmt.Println("Received:", num)
}
}
func main() {
ch := make(chan int)
go sender(ch)
go receiver(ch)
select {}
}
在这个示例中，sender Goroutine 通过通道 ch 向 receiver Goroutine 发送数据。通道 ch 保证了数据传递的安全性，避免了传统多线程编程中常见的竞态条件（race condition）问题。
2. 线程的内存模型
- 线程之间共享进程的内存空间，这意味着多个线程可以直接访问相同的内存区域。虽然这种方式在数据共享方面具有一定的便利性，但也带来了严重的并发安全问题，如竞态条件、死锁等。
- 为了保证线程安全，开发人员需要使用锁（如互斥锁、读写锁等）来同步对共享内存的访问。例如，在 C 语言的多线程编程中，使用互斥锁来保护共享资源：
#include <stdio.h>
#include <pthread.h>
int sharedVariable = 0;
pthread_mutex_t mutex;
void* increment(void* arg) {
pthread_mutex_lock(&mutex);
sharedVariable++;
printf("Incremented: %d\n", sharedVariable);
pthread_mutex_unlock(&mutex);
return NULL;
}
int main() {
pthread_t tid1, tid2;
pthread_mutex_init(&mutex, NULL);
pthread_create(&tid1, NULL, increment, NULL);
pthread_create(&tid2, NULL, increment, NULL);
pthread_join(tid1, NULL);
pthread_join(tid2, NULL);
pthread_mutex_destroy(&mutex);
return 0;
}
在这个示例中，通过 pthread_mutex_lock 和 pthread_mutex_unlock 函数来加锁和解锁，以保护对 sharedVariable 的访问，防止竞态条件的发生。但这种方式增加了编程的复杂性，并且如果锁使用不当，很容易导致死锁等问题。
本质区分 - 错误处理与健壮性
- Goroutine 的错误处理与健壮性
- Goroutine 自身相对轻量级且具有一定的隔离性。当一个 Goroutine 发生未处理的恐慌（panic）时，默认情况下不会导致整个程序崩溃，除非这个恐慌没有被恢复（recover）。
- 例如，下面的代码展示了一个 Goroutine 发生恐慌但不影响其他 Goroutine 执行的情况：
package main
import (
"fmt"
"time"
)
func faultyGoroutine() {
defer func() {
if r := recover(); r != nil {
fmt.Println("Recovered from panic in faultyGoroutine:", r)
}
}()
panic("Oops! Something went wrong in faultyGoroutine")
}
func normalGoroutine() {
for i := 1; i <= 5; i++ {
fmt.Println("Normal Goroutine:", i)
time.Sleep(time.Millisecond * 200)
}
}
func main() {
go faultyGoroutine()
go normalGoroutine()
time.Sleep(time.Second * 2)
}
在这个示例中，faultyGoroutine 发生了恐慌，但通过 defer 和 recover 进行了恢复，normalGoroutine 可以继续正常执行，整个程序不会崩溃。
2. 线程的错误处理与健壮性
- 在传统线程编程中，如果一个线程发生未处理的异常，很可能会导致整个进程崩溃。因为线程共享进程的地址空间，异常可能会破坏进程的内存状态等资源，从而影响其他线程的正常运行。
- 例如，在 C 语言的多线程程序中，如果一个线程发生内存越界访问等未处理的错误，可能会导致整个进程收到段错误（Segmentation Fault）信号，进而崩溃，其他线程也无法继续执行。
本质区分 - 可移植性
- Goroutine 的可移植性
- Goroutine 是 Go 语言运行时提供的特性，其调度和管理机制由 Go 运行时实现。这使得 Goroutine 在不同操作系统上具有较好的可移植性。无论是在 Linux、Windows 还是 macOS 等操作系统上，Go 程序中使用 Goroutine 的方式基本相同，开发人员不需要针对不同操作系统编写大量特定的代码来管理并发执行单元。
- 例如，上述展示 Goroutine 并发执行的代码，在 Linux、Windows 和 macOS 上都可以直接编译运行，不需要修改任何与 Goroutine 相关的代码逻辑。
- 线程的可移植性
- 不同操作系统对线程的支持和实现方式存在一定差异。例如，在 Linux 系统中，线程是通过
clone系统调用实现的，而在 Windows 系统中，线程有其特定的 API（如CreateThread等）。这就导致在编写跨平台的多线程程序时，开发人员需要针对不同操作系统编写不同的代码来创建、管理和同步线程。 - 以创建线程为例，在 Linux 上使用 POSIX 线程库（pthread），而在 Windows 上则使用 Windows 线程 API。如果要编写一个跨平台的多线程程序，就需要使用条件编译等技术来区分不同操作系统并调用相应的线程创建函数，这增加了开发的复杂性和代码的维护成本。
- 不同操作系统对线程的支持和实现方式存在一定差异。例如，在 Linux 系统中，线程是通过
本质区分 - 性能表现
- Goroutine 的性能表现
- 在高并发场景下，Goroutine 由于其轻量级的特性和高效的调度机制，通常具有较好的性能表现。由于其资源占用小，可以创建大量的并发执行单元，适用于处理海量的并发任务。例如，在网络服务器应用中，每个客户端连接可以由一个 Goroutine 来处理，Go 运行时可以高效地调度这些 Goroutine，使得服务器能够处理大量的并发连接而不会因为资源耗尽而性能下降。
- 同时，Goroutine 的协作式调度避免了频繁的上下文切换开销，尤其在 I/O 密集型任务中，当大量 Goroutine 因为 I/O 操作而阻塞时，Go 运行时可以快速地将 CPU 资源分配给其他可运行的 Goroutine，提高了系统的整体利用率。
- 线程的性能表现
- 传统线程在处理少量并发任务时，由于其由操作系统内核直接调度，在一些场景下可能具有较好的性能。但在高并发场景下，由于线程资源占用大，创建大量线程会导致内存开销剧增，同时频繁的上下文切换也会消耗大量的 CPU 时间，从而导致性能下降。
- 例如，在一个需要处理大量并发 I/O 操作的程序中，如果使用线程来处理每个 I/O 请求，随着并发量的增加，线程上下文切换开销会成为性能瓶颈，而使用 Goroutine 则可以更好地应对这种高并发 I/O 场景。
适用场景差异
- Goroutine 的适用场景
- 高并发网络编程：如编写 Web 服务器、网络爬虫等。在 Web 服务器中，每个 HTTP 请求可以由一个 Goroutine 来处理，Go 运行时可以高效地调度这些 Goroutine，处理大量并发请求。
- I/O 密集型任务：例如文件读写、数据库操作等。由于 Goroutine 在 I/O 阻塞时可以快速切换，不会浪费 CPU 资源，适用于这类任务。例如，一个需要同时读取多个文件的程序，可以为每个文件读取操作创建一个 Goroutine。
- 分布式系统开发：在分布式系统中，各个节点之间的通信和任务处理可以通过 Goroutine 高效实现。例如，一个分布式计算系统中，每个节点可以使用 Goroutine 来处理本地任务和与其他节点的通信。
- 线程的适用场景
- 计算密集型任务（少量线程）：对于一些计算密集型任务，如果并发度不高，使用线程可以利用多核 CPU 的优势。例如，一个科学计算程序，可能只需要创建少量线程来并行计算不同的部分，此时线程的直接内核调度可以更好地利用 CPU 资源。
- 与操作系统底层交互紧密的任务：当需要直接与操作系统底层进行交互，如操作特定的硬件设备驱动等，使用线程可能更为合适，因为线程可以更直接地利用操作系统提供的功能。例如，在编写一个实时控制系统时，可能需要使用线程来与硬件设备进行高速数据交互。
通过以上对 Go Goroutine 与线程在资源占用、调度方式、内存模型、错误处理、可移植性、性能表现及适用场景等多方面本质区分的详细分析，可以看出它们各自具有独特的特点和优势。在实际编程中，应根据具体的应用场景和需求，合理选择使用 Goroutine 或线程来实现高效、可靠的并发编程。