并发编程模型

线程模型：Go的Goroutine

• Goroutine（M:N 模型）

  package main
  
  import (
      "fmt"
      "runtime"
      "sync"
      "time"
  )
  
  func main() {
      // 查看当前机器的逻辑CPU核心数，决定Go运行时使用多少OS线程
      fmt.Println("CPU Cores:", runtime.NumCPU())
  
      // 启动一个Goroutine：只需一个 `go` 关键字
      go func() {
          fmt.Println("I'm running in a goroutine!")
      }()
  
      // 启动10万个Goroutine轻而易举
      var wg sync.WaitGroup // 用于等待Goroutine完成
      for i := 0; i < 100000; i++ {
          wg.Add(1)
          go func(taskId int) {
              defer wg.Done() // 任务完成时通知WaitGroup
  
              // 模拟一些工作，比如等待IO
              time.Sleep(100 * time.Millisecond)
              fmt.Printf("Task %d executed.\n", taskId)
          }(i)
      }
      wg.Wait() // 等待所有Goroutine结束
  }
  

• 极轻量：

  • 内存开销极小：初始栈大小仅2KB，并且可以按需动态扩缩容。创建100万个Goroutine也只需要大约2GB内存（主要开销是堆内存），而100万个Java线程需要TB级内存。
  • 创建和销毁开销极低：由Go运行时在用户空间管理，不需要系统调用，只是分配一点内存，速度极快（比Java线程快几个数量级）。

• M:N 调度模型：这是Go高并发的魔法核心。

  • Go运行时创建一个少量的OS线程（默认为CPU核心数，如4核机器就创建4个）。
  • 成千上万的Goroutine被多路复用在这少量的OS线程上。
  • Go运行时自身实现了一个工作窃取（Work-Stealing） 的调度器，负责在OS线程上调度Goroutine。

• 智能阻塞处理：当一个Goroutine执行阻塞操作（如I/O）时，Go调度器会立即感知到。

  • 它会迅速将被阻塞的Goroutine从OS线程上移走。
  • 然后在该OS线程上调度另一个可运行的Goroutine继续执行。
  • 这样，OS线程永远不会空闲，始终保持在忙碌状态。阻塞操作完成后，相应的Goroutine会被重新放回队列等待执行。

通信机制：Go的CSP模型：Channel通信

• 语法和结构

  package main
  
  import (
  	"fmt"
  	"time"
  )
  
  func producer(ch chan<- string) { // 参数：只写Channel
  	ch <- "Data" // 1. 发送数据到Channel（通信）
  	fmt.Println("Produced and sent data")
  }
  
  func consumer(ch <-chan string) { // 参数：只读Channel
  	data := <-ch // 2. 从Channel接收数据（通信）
  	// 一旦收到数据，说明“内存（数据）”的所有权从producer转移给了consumer
  	fmt.Println("Consumed:", data)
  }
  
  func main() {
  	// 创建一个Channel（通信的管道），类型为string
  	messageChannel := make(chan string)
  
  	// 启动生产者Goroutine和消费者Goroutine
  	// 它们之间不共享内存，只共享一个Channel（用于通信）
  	go producer(messageChannel)
  	go consumer(messageChannel)
  
  	// 给Goroutine一点时间执行
  	time.Sleep(100 * time.Millisecond)
  
  	// 更复杂的例子：带缓冲的Channel
  	bufferedChannel := make(chan int, 2) // 缓冲大小为2
  	bufferedChannel <- 1                 // 发送数据，不会阻塞，因为缓冲未满
  	bufferedChannel <- 2
  	// bufferedChannel <- 3               // 这里会阻塞，因为缓冲已满，直到有接收者拿走数据
  
  	fmt.Println(<-bufferedChannel) // 接收数据
  	fmt.Println(<-bufferedChannel)
  
  	// 使用Range和Close
  	go func() {
  		for i := 0; i < 3; i++ {
  			bufferedChannel <- i
  		}
  		close(bufferedChannel) // 发送者关闭Channel，表示没有更多数据了
  	}()
  
  	// 接收者可以用for-range循环自动接收，直到Channel被关闭
  	for num := range bufferedChannel {
  		fmt.Println("Received:", num)
  	}
  }
  

• 核心：Goroutine 是被动的，它们通过 Channel 发送和接收数据来进行协作。通信同步了内存的访问。

• Channel 的行为：

  • 同步：无缓冲 Channel 的发送和接收操作会阻塞，直到另一边准备好。这天然地同步了两个 Goroutine 的执行节奏。
  • 所有权转移：当数据通过 Channel 发送后，可以认为发送方“放弃”了数据的所有权，接收方“获得”了它。这避免了双方同时操作同一份数据。

• 优点：

  • 清晰易懂：数据流清晰可见。并发逻辑由 Channel 的连接方式定义，而不是由错综复杂的锁保护区域定义。
  • 天生安全：从根本上避免了由于同时访问共享变量而引发的数据竞争问题。
  • 简化并发：开发者不再需要费心识别临界区和手动管理锁，大大降低了心智负担和出错概率。

• Go 也提供了传统的锁：sync.Mutex。Channel 并非万能。Go 的理念是：

  • 使用 Channel 来传递数据、协调流程。
  • 使用 Mutex 来保护小范围的、简单的状态（例如，保护一个结构体内的几个字段）。

同步原语：sync.Mutex、WaitGroup

• sync.Mutex（互斥锁）

  package main
  
  import (
  	"fmt"
  	"sync"
  )
  
  type Counter struct {
  	mu    sync.Mutex // 通常将Mutex嵌入到需要保护的数据结构中
  	count int
  }
  
  func (c *Counter) Increment() {
  	c.mu.Lock()         // 获取锁
  	defer c.mu.Unlock() // 使用defer确保函数返回时一定会释放锁
  	c.count++           // 临界区
  }
  

  • 显式操作：类似Java的Lock，需要手动调用Lock()和Unlock()。
  • defer是关键：Go社区强烈推荐使用defer mutex.Unlock()来确保锁一定会被释放，这比Java的try-finally模式更简洁，不易出错。
  • 不可重入：Go的Mutex是不可重入的。如果一个Goroutine已经持有一个锁，再次尝试获取同一个锁会导致死锁。

• sync.WaitGroup（等待组）

  func main() {
      var wg sync.WaitGroup // 创建一个WaitGroup
      urls := []string{"url1", "url2", "url3"}
  
      for _, url := range urls {
          wg.Add(1) // 每启动一个Goroutine，计数器+1
          go func(u string) {
              defer wg.Done() // Goroutine完成时，计数器-1（defer保证一定会执行）
              // 模拟抓取网页
              fmt.Println("Fetching", u)
          }(url)
      }
  
      wg.Wait() // 阻塞，直到计数器归零（所有Goroutine都调用了Done()）
      fmt.Println("All goroutines finished.")
  }
  

  • WaitGroup更简洁：它的API(Add, Done, Wait)专为等待Goroutine组而设计，意图更明确，用法更简单。
  • 无需线程池：WaitGroup直接与轻量的Goroutine配合，而Java通常需要与笨重的线程池(ExecutorService)一起使用。

深度对比：Goroutine与Java线程的轻量级特性

• 用户态线程 vs. 内核态线程

  • Java线程是 1:1 模型的内核态线程，一个Java线程直接对应一个操作系统线程，由操作系统内核进行调度和管理。
  • Goroutine是 M:N 模型的用户态线程，成千上万个Goroutine被多路复用在少量操作系统线程上，在用户空间进行调度和管理。

• 内存开销：Goroutine的内存效率比Java线程高出两个数量级，这使得在普通硬件上运行数十万甚至上百万的并发任务成为可能。

• 创建与销毁：Goroutine的创建和销毁开销极低，这使得开发者可以采用更直观的Goroutine模式，无需纠结于复杂的池化技术。

• 调度：Go调度器的用户态、协作式、工作窃取设计，使得它在高并发场景下的调度效率远高于OS内核调度器。

• 阻塞处理：Go在语言运行时层面完美处理了阻塞问题，而Java需要在应用层通过复杂的非阻塞I/O库来规避此问题。

高级特性与元编程

泛型：Go的[T any]（引入较晚，对比其应用场景）

• 语法和结构

  // 1. 类型参数（Type Parameters）声明：使用方括号 []
  //    `[T any]` 表示一个类型参数T，其约束为`any`（即没有任何约束，可以是任何类型）
  func PrintSlice[T any](s []T) { // 泛型函数
      for _, v := range s {
          fmt.Println(v)
      }
  }
  
  // 2. 自定义约束（Constraints）：使用接口定义类型集
  //    约束不仅可以要求方法，还可以要求底层类型（~int）或类型列表
  type Number interface {
      ~int | ~int64 | ~float64 // 类型约束：只能是int、int64或float64（包括自定义衍生类型）
  }
  
  func Sum[T Number](s []T) T {
      var sum T
      for _, v := range s {
          sum += v
      }
      return sum
  }
  
  // 3. 泛型类型
  type MyStack[T any] struct {
      elements []T
  }
  
  func (s *MyStack[T]) Push(element T) {
      s.elements = append(s.elements, element)
  }
  
  func (s *MyStack[T]) Pop() T {
      element := s.elements[len(s.elements)-1]
      s.elements = s.elements[:len(s.elements)-1]
      return element
  }
  

• 优点：

  • 运行时类型安全：没有类似Java的“原始类型”概念，无法绕过类型检查。
  • 支持基本类型：Sum([]int{1, 2, 3}) 可以直接工作，无装箱开销。
  • 更强大的约束：可以通过接口约束类型集（~int | ~float64），这是Java做不到的。

• 缺点与限制（目前）：

  • 语法略显冗长：[T any] 相比 <T> 更占空间，尤其是多个参数时：[K comparable, V any]。
  • 生态系统仍在适应：标准库和第三方库对泛型的应用是渐进的，不像Java那样无处不在。

反射：Java的Reflection vs Go的reflect

• 语法和结构

  package main
  
  import (
  	"fmt"
  	"reflect"
  )
  
  type Person struct {
  	Name string `json:"name"` // 结构体标签（Tag）
  	Age  int    `json:"age"`
  }
  
  func (p Person) Greet() {
  	fmt.Printf("Hello, my name is %s\n", p.Name)
  }
  
  func main() {
  	// 1. 获取Type和Value（反射的两个核心入口）
  	p := Person{Name: "Alice", Age: 30}
  	t := reflect.TypeOf(p)   // 获取类型信息 (reflect.Type)
  	v := reflect.ValueOf(p)  // 获取值信息 (reflect.Value)
  
  	fmt.Println("Type:", t.Name()) // Output: Person
  	fmt.Println("Kind:", t.Kind()) // Output: struct (Kind是底层分类)
  
  	// 2. 检查结构信息
  	// - 检查结构体字段
  	for i := 0; i < t.NumField(); i++ {
  		field := t.Field(i)
  		tag := field.Tag.Get("json") // 获取结构体标签
  		fmt.Printf("Field %d: Name=%s, Type=%v, JSON Tag='%s'\n",
  			i, field.Name, field.Type, tag)
  	}
  	// - 检查方法
  	for i := 0; i < t.NumMethod(); i++ {
  		method := t.Method(i)
  		fmt.Printf("Method %d: %s\n", i, method.Name)
  	}
  
  	// 3. 动态操作
  	// - 修改值（必须传入指针，且值必须是“可设置的”(Settable)）
  	pValue := reflect.ValueOf(&p).Elem() // 获取可寻址的Value (Elem()解引用指针)
  	nameField := pValue.FieldByName("Name")
  	if nameField.IsValid() && nameField.CanSet() {
  		nameField.SetString("Bob") // 修改字段值
  	}
  	fmt.Println("Modified person:", p) // Output: {Bob 30}
  
  	// - 调用方法
  	greetMethod := v.MethodByName("Greet")
  	if greetMethod.IsValid() {
  		greetMethod.Call(nil) // 调用方法，无参数则传nil
  		// 输出: Hello, my name is Alice (注意：v是基于原始p的Value，名字还是Alice)
  	}
  
  	// 4. 创建新实例
  	var newPPtr interface{} = reflect.New(t).Interface() // reflect.New(t) 创建 *Person
  	newP := newPPtr.(*Person)
  	newP.Name = "Charlie"
  	fmt.Println("Newly created person:", *newP) // Output: {Charlie 0}
  }
  

• 显式且谨慎：API设计清晰地分离了Type和Value，修改值需要满足“可设置性”的条件，这是一种安全机制。

• 功能侧重不同：

  • 强项：对结构体（Struct） 的解析能力极强，是encoding/json等标准库的基石，结构体标签（Tag） 是其特色功能。
  • 弱项：无法访问未导出的成员（小写开头的字段/方法），这是Go反射一个非常重要的安全设计，它维护了包的封装性。

• Kind 的概念：这是Go反射的核心，Kind表示值的底层类型（如reflect.Struct, reflect.Slice, reflect.Int），而Type是具体的静态类型，操作前常需要检查Kind。

• 性能开销：同样有较大开销，应避免在性能关键路径中使用。

• 类型安全：比Java稍好，但Call()等方法依然返回[]reflect.Value，需要手动处理。