Update the README to put more emphasis on situations where internal caches can lead to leaks if not used properly.

Author: shengyanli1982

README.md

@@ -124,9 +124,56 @@ type FixedArray struct {
     - Validate data sizes before processing
 
 3. **Performance Optimization**
+
     - Reuse structs when possible
     - Consider using pools for frequently used structures
 
+4. **Memory Management**
+
+    - The library uses internal 4K buffers for efficient unpacking
+    - When unpacking, slice/string fields in your struct will directly reference these internal buffers
+    - These buffers will remain in memory as long as your struct fields reference them
+    - Example of memory retention:
+
+        ```go
+        type Message struct {
+            Data []byte    // This field will reference the internal buffer
+        }
+
+        func processRetain() {
+            messages := make([]*Message, 0)
+
+            // Each unpacked message's Data field references the internal buffer
+            for i := 0; i < 10; i++ {
+                msg := &Message{}
+                struc.Unpack(reader, msg)
+                messages = append(messages, msg)
+                // The internal buffer can't be GC'ed because msg.Data references it
+            }
+        }
+        ```
+
+    - To release the internal buffer reference, you can either set the field to nil or copy the data:
+
+        ```go
+        func processRelease() {
+            msg := &Message{}
+            struc.Unpack(reader, msg)
+
+            // Method 1: Simply set to nil if you don't need the data anymore
+            msg.Data = nil  // Now msg.Data is nil, no longer references the internal buffer
+
+            // Method 2: Copy data if you need to keep it
+            if needData {
+                dataCopy := make([]byte, len(msg.Data))
+                copy(dataCopy, msg.Data)
+                msg.Data = dataCopy  // Now msg.Data references our copy
+            }
+
+            // The internal buffer can now be GC'ed if no other structs reference it
+        }
+        ```
+
 ## Performance Benchmarks
 
 ```

README_CN.md

@@ -124,9 +124,56 @@ type FixedArray struct {
     - 在处理之前验证数据大小
 
 3. **性能优化**
+
     - 尽可能重用结构体
     - 考虑对频繁使用的结构使用对象池
 
+4. **内存管理**
+
+    - 库使用内部 4K 缓冲区来实现高效解包
+    - 解包时，结构体中的切片/字符串字段会直接引用这些内部缓冲区
+    - 只要您的结构体字段还在引用这些缓冲区，它们就会保留在内存中
+    - 内存保留示例：
+
+        ```go
+        type Message struct {
+            Data []byte    // 这个字段会引用内部缓冲区
+        }
+
+        func processRetain() {
+            messages := make([]*Message, 0)
+
+            // 每个解包的消息的 Data 字段都引用内部缓冲区
+            for i := 0; i < 10; i++ {
+                msg := &Message{}
+                struc.Unpack(reader, msg)
+                messages = append(messages, msg)
+                // 内部缓冲区无法被 GC，因为 msg.Data 引用着它
+            }
+        }
+        ```
+
+    - 要释放对内部缓冲区的引用，您可以将字段设为 nil 或复制数据：
+
+        ```go
+        func processRelease() {
+            msg := &Message{}
+            struc.Unpack(reader, msg)
+
+            // 方法1：如果不再需要数据，直接设为 nil
+            msg.Data = nil  // 现在 msg.Data 为 nil，不再引用内部缓冲区
+
+            // 方法2：如果需要保留数据，进行复制
+            if needData {
+                dataCopy := make([]byte, len(msg.Data))
+                copy(dataCopy, msg.Data)
+                msg.Data = dataCopy  // 现在 msg.Data 引用我们的副本
+            }
+
+            // 如果没有其他结构体引用，内部缓冲区现在可以被 GC 了
+        }
+        ```
+
 ## 性能基准测试
 
 ```