为什么Go不再需要Java风格的GC？- itnext

Go、Julia 和 Rust 等现代语言不需要像 Java C# 使用的那些复杂的垃圾收集器，为什么？
为了解释原因，我们需要了解垃圾收集器的工作原理以及不同语言如何以不同方式分配内存。然而，我们将首先看看为什么 Java 特别需要如此复杂的垃圾收集器。
我将在这里介绍许多不同的垃圾收集器主题：

• 为什么 Java 如此依赖快速 GC。我将介绍 Java 语言本身的一些设计选择，这些选择对 GC 造成很大压力。
• 内存碎片以及它如何影响 GC 设计。为什么这对 Java 很重要，但对 Go 则不那么重要。
• 值类型以及它们如何改变 GC 游戏。
• 分代垃圾收集器以及为什么 Go 不需要垃圾收集器。
• 逃逸分析——Go 用来减少 GC 压力的技巧。
• 压缩垃圾收集器——在 Java 世界中很重要，但不知何故 Go 避免了对它的需要。为什么？
• 并发垃圾收集——Go 如何通过使用多个线程运行并发垃圾收集器来解决许多 GC 挑战。为什么用 Java 做这件事要困难得多。
• 对 Go GC 的常见批评以及为什么该批评背后的许多假设通常有缺陷或完全错误。

// Go: Make an an array of 15 000 Point objects in
type Point struct {
    X, Y int
}
var points [15000]Point

在上面的 Go 代码示例中，我们分配了 15 000 个Point对象。这只是一个单一的分配，产生一个单一的指针。在 Java 中，这需要 15 000 个单独的分配，每个分配产生一个必须被管理的单独引用。每个Point对象都会获得我之前写过的 16 字节标头开销。在 Go、Julia 或 Rust 中，您都不会获得这种开销。对象通常是无标识的。
在 Java 中，GC 获得了 15000 个它必须跟踪和管理的单独对象。Go 只需要跟踪 1 个对象。

• 值类型

type Rect struct {
   Min, Max Point
}

• 值类型还不够

// Go pointer usage
var ptr *Point = &rect.Min // Store pointer to Min in ptr
*ptr = Point(2, 4)         // replace rect.Min

// C# pointer usage
unsafe void foo() {
   ref var ptr = ref rect.Min;
   ptr = new Point(2, 4);
}

1. 使用点的代码必须标记为不安全。这会创建安全性较低且更容易崩溃的代码。
2. 堆栈上分配的纯值类型（所有结构字段必须是值类型）。
3. 在固定范围内，垃圾收集已关闭，使用 fixed 关键字。

• 自定义二级分配器

type Arena []Node

func (arena *Arena) Alloc() *Node {
    if len(*arena) == 0 {
        *arena = make([]Node, 10000)
    }

    n := &(*arena)[len(*arena)-1]
    *arena = (*arena)[:len(*arena)-1]
    return n
}

func buildTree(item, depth int, arena *Arena) *Node { 
    n := arena.Alloc() 
    if depth <= 0 { 
        *n = Node{item, nil , nil } 
    } else { 
        *n = Node{ 
              item, 
              buildTree(2*item-1, depth-1, arena), 
              buildTree(2*item, depth-1, arena), 
        } 
    } 
    return n 
}

这就是为什么拥有真正的指针有好处。如果没有它，您将无法在连续内存块中创建指向元素的指针，如以下行所示：

n := &(*arena)[len(*arena)-1]

1. 迟早你需要进行压缩，这涉及移动数据和固定指针。Arena 分配器不必这样做。
2. 在多线程程序中，碰撞分配器需要锁（除非您使用线程本地存储）。这会扼杀它们的性能优势，要么是因为锁会降低性能，要么是因为线程本地存储会导致碎片，这需要稍后进行压缩。

一般来说，使用一组每线程一个缓存来分配内存可能会更有效，此时您已经失去了bump分配器的优势。所以我会断言，总的来说，有很多警告，今天对多线程程序使用压缩内存分配器没有真正的优势。

func escapingPtr() []int {
   values := []int{4, 5, 10}
   return values
}

fun nonEscapingPtr() int {
    values = []int{4, 5, 10}
    var total int = addUp(values)
    return total
}

• Java 转义分析的局限性

• Go Escape 分析的优势

1. Go 没有像 Java 那样分配那么多的小对象。它可以将大型对象数组分配为单个内存块。
2. 现代内存分配器（例如 Google 的 TCMalloc 或英特尔的 Scalable Malloc）不会对内存进行碎片化。

因此，为 Java 设计内存分配策略时的许多假设前提是不再正确了。
 
分代 GC 与并发 GC 暂停
使用分代 GC 的 Java 策略旨在缩短垃圾收集周期。请记住，Java 必须停止一切以移动数据并修复指针。如果持续时间过长，这会降低性能和响应能力。使用分代 GC，每次减少时间检查的数据更少。
然而，Go 用许多替代策略解决了同样的问题：

1. 因为不需要移动内存和固定指针，所以在 GC 运行期间要做的工作更少。Go GC 只做一个标记和扫描：它会在对象图中查找应该释放的对象。
2. 它同时运行。因此，单独的 GC 线程可以在不停止其他线程的情况下查找要释放的对象。

• 如果垃圾产生的速度比清理速度快怎么办？