Gerenciamento de memória

// O Map do JavaScript mantém a ordem de inserção: o primeiro item é o mais antigo
export class CacheLimitado<K, V> {
  private readonly itens = new Map<K, V>();
  private readonly limite: number;

  constructor(limite: number) {
    this.limite = limite;
  }

  obter(chave: K): V | undefined {
    const valor = this.itens.get(chave);
    if (valor !== undefined) {
      this.itens.delete(chave); // move para o fim: usado agora
      this.itens.set(chave, valor);
    }
    return valor;
  }

  guardar(chave: K, valor: V): void {
    this.itens.delete(chave);
    this.itens.set(chave, valor);
    if (this.itens.size > this.limite) {
      const maisAntigo = this.itens.keys().next().value as K;
      this.itens.delete(maisAntigo);
    }
  }
}

const perfis = new CacheLimitado<number, Perfil>(10_000);

from collections import OrderedDict
from functools import lru_cache
from typing import Generic, Hashable, TypeVar

C = TypeVar("C", bound=Hashable)
V = TypeVar("V")


class CacheLimitado(Generic[C, V]):
    def __init__(self, limite: int):
        self.limite = limite
        self.itens: OrderedDict[C, V] = OrderedDict()

    def obter(self, chave: C) -> V | None:
        if chave not in self.itens:
            return None
        self.itens.move_to_end(chave)  # usado agora
        return self.itens[chave]

    def guardar(self, chave: C, valor: V) -> None:
        self.itens[chave] = valor
        self.itens.move_to_end(chave)
        if len(self.itens) > self.limite:
            self.itens.popitem(last=False)  # remove o mais antigo


perfis: CacheLimitado[int, dict] = CacheLimitado(10_000)


# Para funções, a biblioteca padrão já tem: sempre com maxsize
@lru_cache(maxsize=1024)
def cotacao(moeda: str) -> float: ...

package cache

import (
	"container/list"
	"sync"
)

type entrada[K comparable, V any] struct {
	chave K
	valor V
}

// CacheLimitado é seguro para uso por várias goroutines.
type CacheLimitado[K comparable, V any] struct {
	mu     sync.Mutex
	limite int
	ordem  *list.List // frente: mais recente; fundo: mais antigo
	itens  map[K]*list.Element
}

func Novo[K comparable, V any](limite int) *CacheLimitado[K, V] {
	return &CacheLimitado[K, V]{limite: limite, ordem: list.New(), itens: map[K]*list.Element{}}
}

func (c *CacheLimitado[K, V]) Obter(chave K) (V, bool) {
	c.mu.Lock()
	defer c.mu.Unlock()
	if el, ok := c.itens[chave]; ok {
		c.ordem.MoveToFront(el)
		return el.Value.(*entrada[K, V]).valor, true
	}
	var zero V
	return zero, false
}

func (c *CacheLimitado[K, V]) Guardar(chave K, valor V) {
	c.mu.Lock()
	defer c.mu.Unlock()
	if el, ok := c.itens[chave]; ok {
		el.Value.(*entrada[K, V]).valor = valor
		c.ordem.MoveToFront(el)
		return
	}
	c.itens[chave] = c.ordem.PushFront(&entrada[K, V]{chave, valor})
	if c.ordem.Len() > c.limite {
		maisAntigo := c.ordem.Back()
		c.ordem.Remove(maisAntigo)
		delete(c.itens, maisAntigo.Value.(*entrada[K, V]).chave)
	}
}

import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;

public final class CacheLimitado {
    // LinkedHashMap com ordem de acesso remove o item usado há mais tempo
    public static <K, V> Map<K, V> criar(int limite) {
        var mapa = new LinkedHashMap<K, V>(16, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(Map.Entry<K, V> maisAntigo) {
                return size() > limite;
            }
        };
        return Collections.synchronizedMap(mapa); // seguro entre threads
    }
}

// Uso:
// Map<Long, Perfil> perfis = CacheLimitado.criar(10_000);
// Em produção, a biblioteca Caffeine oferece o mesmo com expiração e melhor desempenho.

using Microsoft.Extensions.Caching.Memory;

// O MemoryCache com SizeLimit exige que cada item declare o seu tamanho.
// Quando cheio, ele recusa itens novos e compacta em segundo plano: não é um LRU.
var perfis = new MemoryCache(new MemoryCacheOptions
{
    SizeLimit = 10_000, // aqui, 1 unidade = 1 item
});

void Guardar(long usuarioId, Perfil perfil) =>
    perfis.Set(usuarioId, perfil, new MemoryCacheEntryOptions
    {
        Size = 1,
        SlidingExpiration = TimeSpan.FromMinutes(10),
    });

Perfil? Obter(long usuarioId) =>
    perfis.TryGetValue(usuarioId, out Perfil? perfil) ? perfil : null;

public record Perfil(long Id, string Nome);