Usar a cache de memória

Esta página descreve como configurar e monitorizar o serviço de memcache para a sua aplicação através da consola. Google Cloud Também descreve como realizar tarefas comuns através da interface JCache e como processar gravações simultâneas através da API memcache do App Engine de baixo nível para Java. Para saber mais sobre o memcache, leia a vista geral do memcache.

Configurar a cache de memória

  1. Aceda à página Memcache na Google Cloud consola.
    Aceda à página do Memcache

  2. Selecione o nível de serviço de memcache que quer usar:

    • Partilhada (predefinição): gratuita e oferece capacidade de cache com base no melhor esforço possível.
    • Dedicado: faturado por GB/hora do tamanho da cache e oferece uma capacidade de cache fixa atribuída exclusivamente à sua aplicação.

    Saiba mais acerca das classes de serviço disponíveis na Vista geral do Memcache.

Usar JCache

O SDK Java do App Engine suporta a interface JCache (JSR 107) para aceder à cache de memória. A interface está incluída no pacote javax.cache.

Com o JCache, pode definir e obter valores, controlar a forma como os valores expiram da cache, inspecionar o conteúdo da cache e obter estatísticas sobre a cache. Também pode usar "listeners" para adicionar um comportamento personalizado ao definir e eliminar valores.

A implementação do App Engine tenta implementar um subconjunto fiel da norma da API JCache. (Para mais informações sobre o JCache, consulte o JSR 107.) No entanto, em vez de usar o JCache, recomendamos que considere usar a API Memcache de baixo nível para aceder a mais funcionalidades do serviço subjacente.

Obter uma instância de cache

Usa uma implementação da interface javax.cache.Cache para interagir com a cache. Obtém uma instância de Cache através de um CacheFactory, que obtém a partir de um método estático no CacheManager. O código seguinte obtém uma instância de Cache com a configuração predefinida:

import java.util.Collections;
import javax.cache.Cache;
import javax.cache.CacheException;
import javax.cache.CacheFactory;
import javax.cache.CacheManager;

// ...
        Cache cache;
        try {
            CacheFactory cacheFactory = CacheManager.getInstance().getCacheFactory();
            cache = cacheFactory.createCache(Collections.emptyMap());
        } catch (CacheException e) {
            // ...
        }

O método createCache() de CacheFactory recebe um mapa de propriedades de configuração. Estas propriedades são abordadas abaixo. Para aceitar os valores predefinidos, atribua ao método um mapa vazio.

Inserir e obter valores

A cache comporta-se como um mapa: armazena chaves e valores através do método put() e obtém valores através do método get(). Pode usar qualquer objeto Serializable para a chave ou o valor.

        String key;      // ...
        byte[] value;    // ...

        // Put the value into the cache.
        cache.put(key, value);

        // Get the value from the cache.
        value = (byte[]) cache.get(key);

Para colocar vários valores, pode chamar o método putAll() com um mapa como argumento.

Para remover um valor da cache (para o remover imediatamente), chame o método remove() com a chave como argumento. Para remover todos os valores da cache da aplicação, chame o método clear().

O método containsKey() recebe uma chave e devolve um boolean (true ou false) para indicar se existe um valor com essa chave na cache. O método isEmpty() testa se a cache está vazia. O método size() devolve o número de valores atualmente na cache.

Configurar a validade

Por predefinição, todos os valores permanecem na cache o máximo possível, até serem removidos devido à pressão da memória, removidos explicitamente pela app ou ficarem indisponíveis por outro motivo (como uma indisponibilidade). A app pode especificar um tempo de expiração para os valores, um período máximo durante o qual o valor vai estar disponível. O prazo de validade pode ser definido como um período relativo ao momento em que o valor é definido ou como uma data e hora absolutas.

Especifica a política de expiração através das propriedades de configuração quando cria a instância da cache. Todos os valores colocados com essa instância usam a mesma política de expiração. Por exemplo, para configurar uma instância de cache para que os valores expirem uma hora (3600 segundos) após serem definidos:

import java.util.HashMap;
import java.util.Map;
import javax.cache.Cache;
import javax.cache.CacheException;
import javax.cache.CacheFactory;
import javax.cache.CacheManager;
import javax.concurrent.TimeUnit;
import com.google.appengine.api.memcache.jsr107cache.GCacheFactory;

// ...
        Cache cache;
        try {
            CacheFactory cacheFactory = CacheManager.getInstance().getCacheFactory();
            Map<Object, Object> properties = new HashMap<>();
            properties.put(GCacheFactory.EXPIRATION_DELTA, TimeUnit.HOURS.toSeconds(1));
            cache = cacheFactory.createCache(properties);
        } catch (CacheException e) {
            // ...
        }

As seguintes propriedades controlam a expiração do valor:

  • GCacheFactory.EXPIRATION_DELTA: expira os valores durante o período indicado em relação ao momento em que são colocados, como um número inteiro de segundos
  • GCacheFactory.EXPIRATION_DELTA_MILLIS: expira os valores durante o período indicado em relação ao momento em que são colocados, como um número inteiro de milissegundos
  • GCacheFactory.EXPIRATION: expire os valores na data e hora indicadas, como java.util.Date

Configurar a política definida

Por predefinição, a definição de um valor na cache adiciona o valor se não existir nenhum valor com a chave especificada e substitui um valor se existir um valor com a chave especificada. Pode configurar a cache para apenas adicionar (proteger os valores existentes) ou apenas substituir valores (não adicionar).

import java.util.HashMap;
import java.util.Map;
import com.google.appengine.api.memcache.MemcacheService;

// ...
        Map<Object, Object> properties = new HashMap<>();
        properties.put(MemcacheService.SetPolicy.ADD_ONLY_IF_NOT_PRESENT, true);

As seguintes propriedades controlam a política definida:

  • MemcacheService.SetPolicy.SET_ALWAYS: adiciona o valor se não existir nenhum valor com a chave, substitui um valor existente se existir um valor com a chave; esta é a predefinição
  • MemcacheService.SetPolicy.ADD_ONLY_IF_NOT_PRESENT: adiciona o valor se não existir nenhum valor com a chave, não faz nada se a chave existir
  • MemcacheService.SetPolicy.REPLACE_ONLY_IF_PRESENT: não fazer nada se não existir nenhum valor com a chave, substituir um valor existente se existir um valor com a chave

A obter estatísticas da cache

A app pode obter estatísticas sobre a sua própria utilização da cache. Estas estatísticas são úteis para monitorizar e ajustar o comportamento da cache. Aceda às estatísticas através de um objeto CacheStatistics, que obtém chamando o método getCacheStatistics() da cache.

As estatísticas disponíveis incluem o número de acessos à cache (obtenções de chaves existentes), o número de falhas de acesso à cache (obtenções de chaves inexistentes) e o número de valores na cache.

import javax.cache.CacheStatistics;

        CacheStatistics stats = cache.getCacheStatistics();
        int hits = stats.getCacheHits();
        int misses = stats.getCacheMisses();

A implementação do App Engine não suporta a reposição das contagens de hit e miss, que são mantidas indefinidamente, mas podem ser repostas devido a condições transitórias dos servidores de memcache.

Monitorização da memcache na Google Cloud consola

  1. Aceda à página Memcache na Google Cloud consola.
    Aceda à página da cache de memória
  2. Consulte os seguintes relatórios:
    • Nível de serviço do Memcache: mostra se a sua aplicação está a usar o nível de serviço partilhado ou dedicado. Se for proprietário do projeto, pode alternar entre os dois. Saiba mais sobre os níveis de serviço.
    • Rácio de resultados: mostra a percentagem de pedidos de dados que foram apresentados a partir da cache, bem como o número bruto de pedidos de dados que foram apresentados a partir da cache.
    • Itens na cache.
    • Idade do item mais antigo: a idade do item em cache mais antigo. Tenha em atenção que a antiguidade de um item é reposta sempre que é usado, seja lido ou escrito.
    • Tamanho total da cache.

  3. Pode realizar qualquer uma das seguintes ações:

    • Nova chave: adicione uma nova chave à cache.
    • Encontrar uma chave: obtenha uma chave existente.
    • Limpar cache: remove todos os pares de chave-valor da cache.

  4. (Apenas memcache dedicado) Consulte a lista de Chaves populares.

    • As "chaves frequentes" são chaves que recebem mais de 100 consultas por segundo (CPS) na memória cache.
    • Esta lista inclui até 100 teclas de atalho, ordenadas pela CPS mais elevada.

Processamento de escritas simultâneas

Se estiver a atualizar o valor de uma chave de memcache que possa receber outros pedidos de escrita concorrentes, tem de usar os métodos de memcache de baixo nível putIfUntouched e getIdentifiable em vez de put e get. Os métodos putIfUntouched e getIdentifiable evitam condições de concorrência, permitindo que vários pedidos processados em simultâneo atualizem o valor da mesma chave de memcache de forma atómica.

O fragmento do código abaixo mostra uma forma de atualizar em segurança o valor de uma chave que pode ter pedidos de atualização concorrentes de outros clientes:

@SuppressWarnings("serial")
public class MemcacheConcurrentServlet extends HttpServlet {

  @Override
  public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException,
      ServletException {
    String path = req.getRequestURI();
    if (path.startsWith("/favicon.ico")) {
      return; // ignore the request for favicon.ico
    }

    String key = "count-concurrent";
    // Using the synchronous cache.
    MemcacheService syncCache = MemcacheServiceFactory.getMemcacheService();

    // Write this value to cache using getIdentifiable and putIfUntouched.
    for (long delayMs = 1; delayMs < 1000; delayMs *= 2) {
      IdentifiableValue oldValue = syncCache.getIdentifiable(key);
      byte[] newValue = oldValue == null
          ? BigInteger.valueOf(0).toByteArray()
              : increment((byte[]) oldValue.getValue()); // newValue depends on old value
      resp.setContentType("text/plain");
      resp.getWriter().print("Value is " + new BigInteger(newValue).intValue() + "\n");
      if (oldValue == null) {
        // Key doesn't exist. We can safely put it in cache.
        syncCache.put(key, newValue);
        break;
      } else if (syncCache.putIfUntouched(key, oldValue, newValue)) {
        // newValue has been successfully put into cache.
        break;
      } else {
        // Some other client changed the value since oldValue was retrieved.
        // Wait a while before trying again, waiting longer on successive loops.
        try {
          Thread.sleep(delayMs);
        } catch (InterruptedException e) {
          throw new ServletException("Error when sleeping", e);
        }
      }
    }
  }

  /**
   * Increments an integer stored as a byte array by one.
   * @param oldValue a byte array with the old value
   * @return         a byte array as the old value increased by one
   */
  private byte[] increment(byte[] oldValue) {
    long val = new BigInteger(oldValue).intValue();
    val++;
    return BigInteger.valueOf(val).toByteArray();
  }
}

Um refinamento que pode adicionar a este código de exemplo é definir um limite para o número de novas tentativas, para evitar o bloqueio durante tanto tempo que o pedido do App Engine expire.

O que se segue?