Como usar o Memcache

Nesta página, você aprenderá a configurar e monitorar o serviço Memcache do seu aplicativo usando o Console do Google Cloud Platform. Descrevemos também como fazer tarefas comuns usando a interface JCache e como processar gravações simultâneas usando a API App Engine Memcache para Java de nível baixo. Para saber mais sobre o Memcache, leia a Visão geral do Memcache.

Como configurar o Memcache

  1. Acesse a página do Memcache no Console do Google Cloud Platform.
    Acessar a página "Memcache"
  2. Selecione o nível de serviço do Memcache que você quer usar:

    • Compartilhado (padrão): é gratuito e fornece capacidade de cache com base no melhor esforço possível.
    • Dedicado: é cobrado por GB/hora do tamanho do cache e fornece capacidade de cache fixa atribuída exclusivamente ao seu aplicativo.

    Saiba mais sobre as classes de serviços disponíveis na Visão geral do Memcache.

Como usar o JCache

O SDK do App Engine para Java é compatível com a interface JCache (JSR 107) para acessar o Memcache. A interface está incluída no pacote javax.cache.

Com o JCache, você pode definir, receber, inspecionar o conteúdo e controlar a expiração de valores no cache, além de conseguir estatísticas sobre ele. Também é possível usar "listeners" para adicionar comportamento personalizado ao definir e excluir valores.

O App Engine tenta implementar um subconjunto fiel da API JCache padrão. Para mais informações sobre o JCache, consulte JSR 107. Portanto, em vez de usar JCache, você pode usar a API Memcache de nível baixo para acessar mais recursos do serviço subjacente.

Como conseguir uma instância de cache

Use uma implementação da interface javax.cache.Cache para interagir com o cache e conseguir uma instância de Cache usando um CacheFactory a partir de um método estático no CacheManager. O código a seguir contém uma instância de Cache com a configuração padrão:

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() do CacheFactory adiciona um Mapa de propriedades de configuração, as quais serão abordadas abaixo. Para aceitar o padrão, forneça ao método um Mapa vazio.

Como inserir e receber valores

O Cache se comporta como um Mapa: você armazena chaves e valores usando o método put() e os recupera usando o método get(). É possível 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 inserir diversos valores, chame o método putAll() com um Mapa como argumento.

Para remover um valor do cache (e eliminá-lo imediatamente), chame o método remove() com a chave como argumento. Para remover todos os valores do cache do aplicativo, chame o método clear().

O método containsKey() usa uma chave e retorna um boolean (true ou false) para indicar se algum valor que consta nela existe no cache. O método isEmpty() testa se o cache está vazio. O método size() retorna o número de valores existentes no cache atualmente.

Como configurar a expiração

Por padrão, todos os valores permanecem no cache o máximo possível até que sejam eliminados devido à pressão da memória, removidos explicitamente pelo aplicativo ou tornem-se indisponíveis por outro motivo (por exemplo, uma interrupção). O aplicativo especifica um período de expiração para os valores, ou seja, um prazo máximo de tempo de disponibilidade para o valor que pode ser definido como um período em relação ao momento em que o valor é determinado ou como uma data/hora absoluta.

Especifique a política de expiração usando as propriedades de configuração ao criar a instância de Cache. Todos os valores inseridos nessa instância usam a mesma política de expiração. Por exemplo, para configurar uma instância de Cache para expirar os valores uma hora (3.600 segundos) depois de 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) {
            // ...
        }

Estas propriedades controlam a expiração de valores:

  • GCacheFactory.EXPIRATION_DELTA: expira os valores do período de tempo estabelecido em relação ao momento em que são inseridos, como um número inteiro de segundos.
  • GCacheFactory.EXPIRATION_DELTA_MILLIS: expira os valores do período de tempo estabelecido em relação ao momento em que são inseridos, como um número inteiro de milissegundos.
  • GCacheFactory.EXPIRATION: expira valores na data/hora determinada, como um java.util.Date.

Como configurar a política de definição

Por padrão, a definição de um valor no cache o adiciona caso ainda não haja um com a chave fornecida e o substitui se já houver. É possível configurar o cache para apenas adicionar (proteger os valores existentes) ou apenas substituir (não adicionar valores).

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);

A seguir, as propriedades que controlam a política de definição:

  • MemcacheService.SetPolicy.SET_ALWAYS: adiciona o valor caso ainda não exista um com a chave e o substitui se já existir, que é o padrão.
  • MemcacheService.SetPolicy.ADD_ONLY_IF_NOT_PRESENT: adiciona o valor caso ainda não exista um com a chave, mas não faz nada se ela já existir.
  • MemcacheService.SetPolicy.REPLACE_ONLY_IF_PRESENT: não faz nada caso ainda não exista um valor com a chave, mas o substitui se existir.

Como recuperar estatísticas de cache

O aplicativo pode recuperar estatísticas sobre o próprio uso do cache. Essas estatísticas são úteis para monitorar e ajustar o comportamento do cache. Acesse as estatísticas usando um objeto CacheStatistics, que você recebe ao chamar o método getCacheStatistics() do Cache.

Entre as estatísticas disponíveis estão o número de ocorrências (recebimento de chaves que existiam), o de ausências (recebimento de chaves que não existiam) e o de valores no 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 aceita a redefinição das contagens de ocorrências e ausências. As contagens de ocorrências e ausências são mantidas indefinidamente, mas podem ser redefinidas devido às condições passageiras dos servidores Memcache.

Como monitorar o Memcache no console do Google Cloud Platform

  1. Acesse a página do Memcache no Console do Google Cloud Platform.
    Acessar a página "Memcache"
  2. Veja os seguintes relatórios:
    • Nível de serviço do Memcache: mostra se o aplicativo está usando o nível de serviço Compartilhado ou Dedicado. Se você for proprietário do projeto, poderá alternar entre os dois. Saiba mais sobre os níveis de serviço.
    • Taxa de acertos: mostra uma porcentagem e o número bruto de acertos e erros do Memcache.
    • Itens no cache.
    • Idade do item mais antigo: a idade do item mais antigo armazenado em cache. Observe que a idade de um item é redefinida sempre que ele é usado, lido ou gravado.
    • Tamanho total do cache.
  3. Você pode realizar uma destas ações:

    • Nova chave: adiciona uma nova chave ao cache.
    • Encontrar uma chave: recupera uma chave existente.
    • Limpar o cache: remove todos os pares de chave-valor do cache.
  4. (Somente no Memcache dedicado) Consulte a lista de chaves com uso intenso.

    • "Chaves de uso intenso" são as que recebem mais de cem consultas por segundo (QPS, na sigla em inglês) no Memcache.
    • Essa lista inclui até 100 chaves de uso intenso classificadas pelo QPS mais alto.
    • Leia o artigo Práticas recomendadas para o Memcache do App Engine para conferir dicas de como distribuir a carga de maneira mais uniforme em todo o keyspace.

Como processar gravações simultâneas

Ao atualizar o valor de uma chave do Memcache que possa receber outras solicitações de gravação simultâneas, use os métodos do Memcache de nível mais baixo putIfUntouched e getIdentifiable, em vez de put e get. Os métodos putIfUntouched e getIdentifiable evitam disputa, porque permitem que várias solicitações que estão sendo processadas simultaneamente atualizem o valor da mesma chave do Memcache atomicamente.

O snippet de código abaixo mostra uma maneira de atualizar com segurança o valor de uma chave que pode ter solicitações de atualização simultânea 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();
  }
}

Como refinamento extra ao código de amostra, é possível definir um limite para o número de tentativas. O objetivo é evitar bloqueios tão demorados que façam a solicitação do App Engine expirar.

Próximas etapas

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Ambiente padrão do App Engine para Java 8