# Garbage Collection

Garbage Collection (GC) trong Go là một cơ chế tự động quản lý bộ nhớ, giúp giải phóng bộ nhớ không còn được sử dụng mà không cần lập trình viên can thiệp thủ công. Để giải thích chi tiết như một senior, mình sẽ đi sâu vào cách hoạt động của GC trong Go, thuật toán, các đặc điểm nổi bật, và cách tối ưu hóa hiệu suất liên quan đến GC.

***

#### 1. Tổng quan về Garbage Collection trong Go

Go sử dụng một **mark-and-sweep garbage collector** không phân thế hệ (non-generational) với thiết kế tập trung vào độ trễ thấp (low latency) và hiệu suất cao, phù hợp cho các ứng dụng thời gian thực hoặc hệ thống yêu cầu phản hồi nhanh. GC trong Go được tích hợp trong runtime của ngôn ngữ, giúp tự động phát hiện và thu hồi các đối tượng không còn được tham chiếu.

**Đặc điểm chính:**

* **Concurrent**: GC chạy đồng thời với chương trình chính (goroutines), giảm thiểu thời gian dừng (stop-the-world).
* **Non-generational**: Không phân biệt đối tượng theo "thế hệ" như nhiều ngôn ngữ khác (Java, .NET), giúp đơn giản hóa nhưng đôi khi kém hiệu quả với ứng dụng có nhiều đối tượng ngắn hạn.
* **Mark-and-sweep**: Sử dụng thuật toán đánh dấu và quét để xác định và thu hồi bộ nhớ.
* **Low-latency focus**: Từ Go 1.5, GC được tối ưu để giảm độ trễ, phù hợp với các ứng dụng như web server hoặc hệ thống phân tán.
* **Pacing algorithm**: GC điều chỉnh tần suất chạy dựa trên tỷ lệ phân bổ bộ nhớ (allocation rate) và tham số `GOGC`.

***

#### 2. Cách hoạt động của Garbage Collection trong Go

GC trong Go hoạt động theo hai giai đoạn chính: **Mark** và **Sweep**.

**Giai đoạn Mark**

* **Mục tiêu**: Xác định các đối tượng còn "sống" (reachable) trong bộ nhớ.
* **Cách hoạt động**:
  * GC bắt đầu từ các **root objects** (như stack của goroutines, global variables, hoặc các con trỏ trong CPU registers).
  * Nó duyệt qua biểu đồ đối tượng (object graph), đánh dấu tất cả các đối tượng có thể truy cập được từ các root này.
  * Go sử dụng cơ chế **write barrier** để đảm bảo các con trỏ mới được tạo trong khi GC đang chạy cũng được ghi nhận chính xác.
* **Concurrency**: Giai đoạn mark chạy đồng thời với chương trình (mutator). Điều này được thực hiện thông qua mô hình **tri-color marking**:
  * **White**: Đối tượng chưa được kiểm tra (có thể bị thu hồi).
  * **Grey**: Đối tượng đang được kiểm tra (được tham chiếu nhưng chưa duyệt hết).
  * **Black**: Đối tượng đã được kiểm tra và xác định là còn sống.
  * Write barrier đảm bảo rằng nếu một con trỏ mới được tạo trong lúc mark, nó sẽ được đưa vào danh sách grey để kiểm tra.

**Giai đoạn Sweep**

* **Mục tiêu**: Thu hồi bộ nhớ từ các đối tượng không còn được tham chiếu (white objects).
* **Cách hoạt động**:
  * Sau khi mark hoàn tất, GC duyệt qua heap và giải phóng các đối tượng không được đánh dấu (white).
  * Bộ nhớ được trả lại cho allocator để tái sử dụng.
* **Concurrency**: Giai đoạn sweep có thể chạy đồng thời với chương trình, nhưng thường ít tốn CPU hơn mark.

**Stop-the-world (STW)**

* Mặc dù Go tối ưu để giảm STW, vẫn có những khoảnh khắc ngắn khi chương trình bị tạm dừng:
  * **Bắt đầu mark**: Để khởi tạo write barrier và các cấu trúc dữ liệu cần thiết.
  * **Kết thúc mark**: Để chuyển từ mark sang sweep.
* Từ Go 1.5, thời gian STW đã được giảm đáng kể (thường dưới 1ms trong các ứng dụng thông thường).

***

#### 3. GOGC và Pacing

Go sử dụng một tham số quan trọng là `GOGC` để điều chỉnh tần suất chạy GC. Mặc định, `GOGC=100`.

* **Ý nghĩa của GOGC**:
  * Giá trị `GOGC` xác định tỷ lệ tăng kích thước heap trước khi kích hoạt GC tiếp theo.
  * Ví dụ: `GOGC=100` nghĩa là heap được phép tăng gấp đôi (100%) so với kích thước heap còn sống sau lần GC trước đó trước khi kích hoạt GC mới.
  * Công thức: `NextGC = LiveHeapSize * (1 + GOGC/100)`.
* **Tác động của GOGC**:
  * **GOGC cao (ví dụ: 200)**: GC chạy ít thường xuyên hơn, tăng throughput nhưng tiêu tốn nhiều bộ nhớ hơn.
  * **GOGC thấp (ví dụ: 50)**: GC chạy thường xuyên hơn, giảm sử dụng bộ nhớ nhưng tăng chi phí CPU do GC.
* **Pacing algorithm**:
  * Go sử dụng một thuật toán pacing để tự động điều chỉnh tần suất GC dựa trên tốc độ phân bổ bộ nhớ (allocation rate) và hiệu suất ứng dụng.
  * Điều này đảm bảo GC không chạy quá thường xuyên (gây tốn CPU) hoặc quá hiếm (gây tiêu tốn bộ nhớ).

***

#### 4. Tối ưu hóa Garbage Collection

Để tối ưu hóa hiệu suất GC trong Go, các lập trình viên cần hiểu cách quản lý bộ nhớ và tương tác với GC. Dưới đây là một số mẹo từ góc nhìn của một senior:

**a. Giảm allocation**

* **Tránh tạo đối tượng không cần thiết**: Ví dụ, sử dụng `[]byte` thay vì `string` khi làm việc với dữ liệu lớn, vì `string` là immutable và có thể tạo ra nhiều bản sao.
* **Tái sử dụng bộ nhớ**: Sử dụng `sync.Pool` để tái sử dụng các đối tượng tạm thời (temporary objects) như buffers.
* **Slice pre-allocation**: Khai báo capacity cho slice (`make([]T, 0, capacity)`) để tránh resize không cần thiết mot thiết.

**b. Tối ưu hóa GOGC**

* Tùy chỉnh `GOGC` dựa trên workload:
  * Ứng dụng latency-sensitive (web server): Giảm `GOGC` (ví dụ: 50) để giữ footprint bộ nhớ thấp.
  * Ứng dụng batch processing: Tăng `GOGC` (ví dụ: 200) để tăng throughput.
* Điều chỉnh `GOGC` thông qua biến môi trường:

  ```bash
  export GOGC=50
  ```

  hoặc trong code:

  ```go
  debug.SetGCPercent(50)
  ```

**c. Sử dụng profiling**

* Sử dụng `pprof` để phân tích hiệu suất GC:

  ```go
  import "runtime/pprof"
  pprof.WriteHeapProfile(file)
  ```
* Kiểm tra tần suất GC và thời gian chạy qua `runtime.MemStats` hoặc công cụ như `go tool pprof`.

**d. Tránh thoát con trỏ (Pointer Escape)**

* Khi con trỏ thoát ra khỏi stack (escape to heap), nó sẽ được quản lý bởi GC, làm tăng áp lực lên GC.
* Sử dụng `go build -gcflags="-m"` để kiểm tra các trường hợp escape và tối ưu code.

**e. Sử dụng Finalizers (thận trọng)**

* Go hỗ trợ `runtime.SetFinalizer` để chạy hàm cleanup khi một đối tượng bị thu hồi. Tuy nhiên, finalizers làm tăng chi phí GC và nên được sử dụng cẩn thận.

***

#### 5. Một số lưu ý nâng cao

* **GC Trigger**: GC có thể được kích hoạt thủ công bằng `runtime.GC()`, nhưng điều này hiếm khi cần thiết vì pacing algorithm tự động quản lý tốt.
* **Memory Ballast**: Trong các ứng dụng cần giữ một lượng bộ nhớ lớn cố định (ví dụ: để tránh spike), có thể sử dụng ballast:

  ```go
  var ballast = make([]byte, 100<<20) // 100MB ballast
  ```
* **Trade-off**: Tối ưu GC là cân bằng giữa CPU (tần suất GC) và memory (kích thước heap). Cần đo lường thực tế bằng profiling để đưa ra quyết định đúng.

***

#### 6. Kết luận

Garbage Collection trong Go là một hệ thống mạnh mẽ, được thiết kế để giảm độ trễ và dễ sử dụng. Tuy nhiên, để đạt hiệu suất tối ưu, lập trình viên cần hiểu rõ cách GC hoạt động, điều chỉnh `GOGC`, giảm allocation không cần thiết, và sử dụng công cụ profiling. Việc tối ưu hóa GC đòi hỏi sự cân bằng giữa throughput, latency, và memory footprint, tùy thuộc vào đặc điểm của ứng dụng.
