Lees en Go un archivo grande o la respuesta de una API en buf, recortas los 16 bytes que necesitas con part := buf[:16] y los guardas en caché. Parece que dejaste una migaja en memoria, pero el consumo de RAM del servicio crece sin parar.
La trampa está en cómo funciona un slice. Por dentro es una cabecera con un puntero ptr, longitud len y capacidad cap que apunta a un arreglo subyacente compartido (backing array), el bloque real de memoria con los datos. Escribir buf[:16] no copia nada: part mira al mismo arreglo, y modificar part[0] cambia buf[0]. Mientras part siga vivo, el recolector de basura (GC) no puede liberar el búfer original entero, aunque buf haya salido de la función hace rato. En el blog oficial de Go lo ilustran con FindDigits: lee un archivo completo, recorta un par de dígitos con una expresión regular y mantiene todo el archivo atrapado en RAM.
Para romper el enlace con el búfer viejo hay que copiar los datos:
// Peligroso: part retiene en memoria todo el arreglo original buf
part := buf[:16]
// Seguro: creamos un arreglo independiente de 16 bytes
saved := make([]byte, len(part))
copy(saved, part)
// En Go 1.21+ lo mismo en una sola línea:
// saved := slices.Clone(buf[:16])
Después de copy o slices.Clone, el slice saved vive en su propio arreglo diminuto, y el búfer grande se liberará en cuanto desaparezcan las demás referencias. Conviene copiar solo cuando el slice corto sobrevive a un búfer grande; de lo contrario, sería una asignación innecesaria.
