1. 性能开销
- Go语言（goroutine）：goroutine是一种轻量级的线程，其创建和销毁的开销极小。一个程序可以轻松创建数以万计的goroutine，因为它们只需要极少量的栈空间（初始时可能只有2KB），并且栈空间可以根据需要动态增长和收缩。例如，在一个简单的Web服务器中，每来一个新的HTTP请求，就可以轻松地启动一个goroutine来处理，而不会造成资源耗尽。
package main
import (
"fmt"
)
func worker(id int) {
fmt.Printf("Worker %d starting\n", id)
}
func main() {
for i := 0; i < 10000; i++ {
go worker(i)
}
}
- Python（多线程）：Python的线程是基于操作系统线程实现的，创建和销毁开销较大。每个线程需要数MB的栈空间，这使得在高并发场景下，创建大量线程会迅速耗尽系统资源。例如，在Python中尝试创建10000个线程可能会导致内存不足或系统崩溃。
2. 全局解释器锁（GIL）
- Go语言：Go语言没有类似Python GIL这样的限制。每个goroutine都可以并行执行在多个CPU核心上，充分利用多核处理器的性能。例如，在一个计算密集型的任务中，多个goroutine可以同时在不同的CPU核心上运算，提高整体计算速度。
package main
import (
"fmt"
"sync"
)
func sum(a, b int, wg *sync.WaitGroup) {
defer wg.Done()
fmt.Printf("%d + %d = %d\n", a, b, a+b)
}
func main() {
var wg sync.WaitGroup
for i := 0; i < 4; i++ {
wg.Add(1)
go sum(i, i+1, &wg)
}
wg.Wait()
}
- Python：Python的多线程由于GIL的存在，在同一时刻只有一个线程能在CPU上执行，即使是在多核处理器上。这就导致Python多线程在计算密集型任务中无法充分利用多核优势，性能提升有限。比如在进行大量数值计算时，Python多线程程序的执行速度并不会随着线程数的增加而显著提升。
3. 通信与同步
- Go语言（channel）：Go语言通过channel进行通信来实现数据共享和同步，遵循“不要通过共享内存来通信，而要通过通信来共享内存”的原则。这种方式使得并发编程中的数据同步和共享更加清晰和安全。例如，在生产者 - 消费者模型中，生产者可以通过channel将数据发送给消费者，消费者从channel中接收数据，避免了共享内存带来的竞争条件。
package main
import (
"fmt"
)
func producer(ch chan int) {
for i := 0; i < 5; i++ {
ch <- i
}
close(ch)
}
func consumer(ch chan int) {
for val := range ch {
fmt.Printf("Consumed %d\n", val)
}
}
func main() {
ch := make(chan int)
go producer(ch)
consumer(ch)
}
- Python：Python多线程通常使用锁（如
threading.Lock）来保护共享资源，以避免竞争条件。但这种方式容易引发死锁等问题，并且代码的复杂度会随着锁的数量和使用场景的增加而迅速上升。例如，在多个线程同时访问和修改一个共享的列表时，需要使用锁来保证数据的一致性，但如果锁的使用不当，就可能导致死锁。
import threading
shared_list = []
lock = threading.Lock()
def modify_list():
global shared_list
with lock:
shared_list.append(1)
