Este artigo tem a natureza de “Primeiros Socorros”. Uma descrição detalhada de ações específicas que permitem instalar e configurar o memcached no servidor.

Vamos começar com uma definição.

Memcached - programas, que implementa um serviço de cache de dados em BATER baseado em uma tabela hash.

Dados iniciais:

• VPS trabalhando para sistema operacional Debian;
• um site válido que pode ser acessado via FTP, SSH.

Vamos começar com o último ponto. Graças a um recurso de Internet em execução (ou algo semelhante), podemos descobrir de forma rápida e fácil o que instalamos (talvez encontremos memcached, entre outras coisas). Vamos criar um arquivo chamado info.php no qual escreveremos:

Vamos executar o código acessando http://example.com/info.php:

Se, entre tudo mais, você encontrar uma entrada semelhante, então está tudo em ordem e o trabalho já foi feito. Caso contrário, obteremos este resultado com base nas ações descritas nesta publicação.

Instalando o servidor Memcached

Vamos iniciar a instalação com o comando

Apt-get instalar memcached php5-memcache

Estamos aguardando a conclusão da instalação. Então verificaremos os resultados com o comando netstat

Como resultado obtemos:

TCP 0 0 *:11211 *:* ESCUTE 13053/memcached

Como podemos ver, por padrão o memcached “escuta” a porta 11211. Portanto, através desta porta qualquer pessoa pode se conectar e usar nosso servidor memcached. Vamos nos proteger dando esse direito apenas ao nosso servidor (localhost). Abra o arquivo /etc/memcached.conf através do painel de controle ou do console:

Veja /etc/memcached.conf

Este arquivo contém comentários detalhados. Não deixe de conferir.

Adicione a linha -l 127.0.0.1 .

Reinicie o servidor memcached com o comando:

/etc/init.d/memcached reiniciar

E vamos verificar novamente:

Netstat -tap | grep memcached

Como resultado deveríamos obter algo como

Tcp 0 0 localhost.localdo:11211 *:* OUÇA 13092/memcached

Agora o memcached só funciona no servidor local.

Instalando o memcache

Lista de comandos (a versão do memcache pode ser diferente!):

Apt-get install php5-dev libmemcache-dev pecl download memcache tar xzvf memcache-2.2.6.tgz cd memcache-2.2.6/ phpize && ./configure --enable-memcache && make cp module/memcache.so /usr/ lib/php5/20060613/ echo "extension=memcache.so" >> /etc/php5/apache2/php.ini

Reinicie o Apache:

Apachectl gracioso

Vamos verificar o script que postamos anteriormente em http://example.com/info.php. Agora devemos encontrar o item Memcache lá.

Vamos verificar o funcionamento do Memcached

Vamos criar um arquivo result.php e executá-lo.

connect("localhost", 11211) ou exit("Não foi possível conectar ao servidor Memcached"); $versão = $memcache->getVersion(); echo Versão do "servidor: ".$version."
\n"; $tmp_object = new stdClass; $tmp_object->str_attr = "test"; $tmp_object->int_attr = 123; $memcache->set("key", $tmp_object, false, 10) ou morrer ("Não Consegui deixar uma entrada no Memcached"); echo "Escrevemos dados no cache do Memcached (os dados serão armazenados por 10 segundos)
\n"; $get_result = $memcache->get("key"); echo "Dados gravados no Memcached:
\n"; var_dump($get_result); ?>

O resultado do roteiro:

Versão do servidor: 1.4.13 Grava dados no cache do Memcached (os dados serão armazenados por 10 segundos) Dados gravados no Memcached: object(stdClass)#3 (2) ( ["str_attr"]=> string(4) " teste" ["int_attr"]=> int(123) )

É tudo assim ou quase assim? Então está tudo bem. Caso contrário, tente repetir os procedimentos.

Já foi feita uma publicação com. Vamos voltar a este tópico e examinar a prática de trabalhar com o memcached usando exemplos.

Infelizmente, ainda não consigo blogar ativamente, mas finalmente apareceu a primeira pessoa para responder. Seu nome Vladislav Klimenko e ele é o autor deste post, e eu atuo apenas como editor. Talvez este exemplo incentive outros leitores a participarem do retorno Insight TI para a vida.

Sinceramente,
Ivan Blinkov

Então, algumas palavras sobre o assunto da conversa. memcached é um sistema distribuído de cache de objetos na memória. Desenvolvido pela empresa (aliás, eles são autores não só do memcached, mas também de outros projetos interessantes). Mas talvez mais sobre eles na próxima vez. Normalmente, o memcached é usado por aplicativos para armazenar temporariamente dados que precisam ser lidos com frequência. Os aplicativos (normalmente) não interagem diretamente com o servidor memcached, mas operam usando bibliotecas cliente. Atualmente, foram criadas bibliotecas para muitas linguagens de programação (e para algumas, várias alternativas) - uma lista completa de bibliotecas clientes está disponível em. Em geral, esse esquema é semelhante ao trabalho com um banco de dados familiar para muitos desenvolvedores.

Consideraremos a instalação e o uso do memcached para Linux. Além disso, ao considerar exemplos em PHP e revisar o cache de sessão, você precisará de PHP e Apache. Talvez seja necessário instalá-los, mas não nos concentraremos em problemas de instalação.

servidor memcached

Vamos começar a instalar o memcached. Em quase todas as distribuições Linux, o memcached pode ser instalado a partir de repositórios. Se você deseja coletar a versão mais recente, pode dar uma olhada (no momento em que escrevo estas linhas, a versão mais recente é). Você também pode precisar instalar o libevent. Versão estável mais recente -

Montamos, instalamos e executamos o memcached no modo de saída de mensagem. É interessante ver o que acontece com ele:

O processo inicia e aguarda conexões (por padrão na porta 11211). A parte do servidor está pronta para processar conexões de clientes e armazenar em cache os dados recebidos.

Mas para um desenvolvedor de aplicativos, isso é apenas metade da jornada. Você precisa oferecer suporte ao trabalho com memcached em seu aplicativo. Para fazer isso, vamos dar uma olhada em algumas bibliotecas clientes existentes do memcached.

clientes memcached

Da variedade de bibliotecas clientes, consideraremos duas:

• libmemcached (para C);
• Extensão PECL para PHP (construída na biblioteca anterior).

Si

A biblioteca libmemcached está sendo desenvolvida ativamente e parece ser a escolha mais adequada ao trabalhar com C e PHP. Além disso, a própria biblioteca cliente inclui utilitários adicionais para trabalhar com o memcached, permitindo visualizar, definir e excluir valores no cache do memcached. Aliás, é surpreendente que o conjunto de utilitários não venha com a parte do servidor, mas sim com a biblioteca cliente.

Então, vamos começar a instalar o libmemcached. No momento em que este livro foi escrito, a versão atual do libmemcached era . Compilamos e instalamos. Primeiro, vamos aproveitar a leitura das páginas de manual:

homem libmemcached homem libmemcached_examples

A biblioteca vem com descrições de exemplos simples de uso. Para métodos de aplicação mais interessantes, faz sentido consultar os códigos-fonte dos utilitários, pois tudo anda junto.

• memstat - exibe informações sobre o servidor memcached
• memcat – retorna valor por chave
• memrm - exclui um valor por chave
• memdump - produz uma lista de chaves

Primeiro, vamos ver o que diz o servidor memcached, que lançamos um pouco antes no modo de saída de mensagens. Vamos solicitar estatísticas do servidor usando o utilitário memstat:

memstat --servers localhost Listagem 1 Servidor Servidor: localhost (11211) pid: 14534 uptime: 1950 time: 1247390264 versão: 1.4.0 pointer_size: 32 rusage_user: 0,0 rusage_system: 0,0 curr_items: 0 total_items: 0 bytes: 0 curr_connections: 10 total _conexões: 11 estruturas_de conexão: 11 cmd_get: 0 cmd_set: 0 get_hits: 0 get_misses: 0 despejos: 0 bytes_read: 0 bytes_write: 0 limit_maxbytes: 67108864 threads: 5

Recebemos estatísticas - portanto, o memcached está funcionando e respondendo às solicitações.

Portanto, no momento, o servidor memcached e a biblioteca cliente estão prontos para uso. Resta implementar o uso do memcached na aplicação que está sendo desenvolvida. Quanto ao aplicativo, tudo está nas mãos dos desenvolvedores, e veremos um pequeno exemplo de trabalho com funções básicas.

memcached fornece o seguinte conjunto de funções básicas (há, é claro, mais, mas aqui estão as principais):

• definir- armazenar em cache um par de valores-chave
• adicionar- adicionar um valor ao cache, desde que ainda não exista nenhum valor com essa chave no cache
• substituir- atualiza o cache desde que um valor com essa chave já esteja no cache
• pegar- obtém um valor do cache usando a chave especificada

Exemplo de programa C

#include "stdio.h" #include "string.h" #include "memcached.h" int main ( void ) ( char * key = "key" ; char * value = "value" ; uint32_t flags = 0 ; size_t length = 0 ; char * value2 = NULL ; memcached_return rc ; !} // 1. crie uma estrutura para trabalhar com o cache memcached_st * memc = memcached_create(NULL); // 2. especifique o servidor com o qual trabalharemos memcached_server_add(memc, "localhost", 11211); // 3. armazena o par chave-valor no cache rc = memcached_set (memc, chave, strlen (chave), valor, strlen (valor) + 1, (time_t) 0, sinalizadores); if (rc == MEMCACHED_SUCCESS) () senão ( } //trata o erro// 4. obtém o valor if (rc == MEMCACHED_SUCCESS) () senão ( } valor2 = memcached_get(memc, chave, strlen(chave), &comprimento, &flags, &rc); if (rc == MEMCACHED_SUCCESS ) ( printf ( "%s \n " , valor2 ); free ( valor2 ); ) else (

// 5. libera a estrutura

memcached_free(memc);

retornar 0;

)

O programa consiste em 5 operações principais e não necessita de comentários especiais. Pode-se apenas notar que no ponto 2 você pode adicionar muitos servidores se usar um sistema distribuído. Para compilar, talvez seja necessário especificar explicitamente os caminhos para as bibliotecas:!

Para mais detalhes, veja as mensagens no servidor memcached:

<32 new auto-negotiating client connection 32: Client using the ascii protocol 32 STORED 32 sending key key >32 FIM<32 quit <32 connection closed.

Este exemplo mostra os seguintes eventos: conexão do cliente, configuração de um par chave-valor, leitura de dados principais e desconexão do cliente.

Vejamos as estatísticas do servidor:

memstat --servers localhost Listagem 1 Servidor Servidor: localhost (11211) pid: 14534 tempo de atividade: 4659 tempo: 1247392973 versão: 1.4.0 pointer_size: 32 rusage_user: 0,0 rusage_system: 0,0 curr_items: 1 total_items: 1 bytes: 58 curr_connections: : 13 estruturas de conexão: 11 cmd_get: 1 cmd_set: 1 get_hits: 1 get_misses: 0 despejos: 0 bytes_read: 58 bytes_write: 58 limit_maxbytes: 67108864 threads: 5

As próximas duas linhas mostram que um valor apareceu no cache:

itens_curr: 1 itens_totais: 1

Vejamos este valor:

memcat --servers valor da chave localhost

Então, o aplicativo usando memcached está pronto.

PHP

Primeiro, vamos instalar a extensão PECL para PHP - memcached

pecl instalar memcached

Nesta fase, você pode receber uma mensagem de erro como:

ERRO: "phpize" falhou

Isso significa que o pacote php-dev ou equivalente não está instalado. Instale-o e você pode tentar novamente:

pecl install memcached install ok: channel://pecl.php.net/memcached-1.0.0 Você deve adicionar "extension=memcached.so" ao php.ini

Como fomos aconselhados, adicione extension=memcached.so ao php.ini e reinicie o Apache.

Vejamos as informações sobre o PHP utilizado:

suporte memcached habilitado Versão 1.0.0 libmemcached versão 0.31 Suporte de sessão sim suporte igbinário não

Exemplo de programa em PHP

Você pode usar chamadas para memcached com segurança do PHP. Como sempre, vejamos um exemplo:

addServer("localhost", 11211);

$m -> set("phpkey" , "phpvalue" );

var_dump ($m -> get("phpkey" ));

?>

O resultado deste script:

string(8) "valorphp"

Então, seu aplicativo PHP usando memcached está pronto.

Armazenando dados da sessão em cache Memcached também pode ser usado como armazenamento de dados de sessão para PHP. Essa abordagem é frequentemente usada em aplicações reais. Vejamos o que precisa ser feito para isso. Fazendo alterações no php.ini

;session.save_handler = arquivos session.save_handler = memcached

Reinicie o Apache - e pronto!

Agora precisamos verificar se os dados da sessão estão realmente armazenados não no disco, mas no memcached.

Vejamos o trabalho de um script simples que adiciona algo a uma sessão:

Executamos o script, ele insere os dados na sessão, após o que olhamos o cache

memdump --servidores localhost chave keyphp memc.sess.key.3ff8ccab14424082ff83a6dfbcf0941f

Portanto, às chaves com as quais estamos familiarizados nos exemplos anteriores, foi adicionada uma chave com o nome de característica memc.sess.key..

O armazenamento de dados da sessão foi movido para o sistema de cache. Mais informações detalhadas Você pode ler sobre como trabalhar com memcached em PHP.

Conclusão

Vimos a instalação e exemplos de uso do memcached. Deve-se enfatizar especialmente que o memcached não é um sistema de armazenamento de dados, portanto, na prática, o memcached é quase sempre usado em conjunto com um banco de dados. Você também deve prestar atenção à invalidação oportuna de dados no cache e às questões de segurança. Em geral, o tema é interessante e ainda está longe de ser encerrado.

Artigo para iniciantes. Memcached é uma ferramenta para armazenar dados em cache na RAM do servidor.

Qual é o objetivo? O site geralmente obtém dados do banco de dados, e o banco de dados é um arquivo grande em disco, e a leitura do disco é a priori mais lenta do que da memória. Isso não começa a aparecer imediatamente - assim que o atendimento ultrapassa várias dezenas de milhares de pessoas e as tabelas no banco de dados crescem para centenas de milhares de linhas. Além disso, a própria base de dados é, por definição, ineficiente. Digamos que armazenamos 1.000.000 de postagens no banco de dados, mas nos últimos dias, 95% de todas as visualizações foram de apenas 100 postagens. Mas toda vez que temos que entrar em um enorme arquivo de banco de dados e procurar nele vários registros solicitados com frequência - e isso aumenta a carga no servidor e o tempo que leva para abrir o site. Se colocarmos essas entradas no cache, aceleraremos o site e não haverá necessidade de comprar servidores poderosos. Em uma palavra, dinheiro é lucro!

O cache vem em diferentes formas. A coisa mais simples é armazenar em cache o arquivo . A desvantagem é que os dados ainda estão armazenados no disco e isso pode levar a consequências terríveis. Você pode armazenar em cache os resultados intermediários no banco de dados (por exemplo, os resultados da pesquisa em alguns mecanismos de fórum são armazenados no banco de dados). Bem, o mais eficaz é, claro, o armazenamento em RAM. Há muitas coisas para isso programas de terceiros: Memcached, eAccelerator, APC, XCache. A propósito, o MySQL também pode armazenar dados em seu cache (não estamos falando de índices na memória).

Em geral, eles escrevem que eAccelerator e XCache são mais eficientes que Memcached se você usar um servidor, já que no caso do Memcached é necessário abrir uma conexão TCP. Mas o Memcached tem a principal vantagem: a capacidade de distribuir dados entre vários servidores. Por exemplo, o cache do LiveJournal não cabe na memória nem mesmo do servidor mais poderoso. Na verdade, o Memcached foi inventado para o LiveJournal para que os dados pudessem ser armazenados em vários servidores. Mas para nós, iniciantes, é muito cedo para pensar nisso.

Recursos do Memcached

• Estrutura simples de armazenamento de dados (valor-chave).
• A vida útil máxima do cache é de 30 dias.
• O volume máximo de um elemento é 1 Mb
• Você pode armazenar objetos e matrizes como estão. Ao armazenar em cache em arquivos ou no banco de dados, essas coisas precisam ser colocadas em uma string usando serialização antes de salvar.
• Sem autorização (login com senha). Aqueles. se o servidor tiver Memcached, qualquer usuário no mesmo servidor poderá acessá-lo.
• A velocidade de acesso aos dados não depende do número de elementos no cache. Sim, sim, está certo.

Instalação

Existem muitas instruções de instalação na rede, seja em Unix ou Windows. Além do próprio Memcached, você também precisa instalar uma lib para acessar o Memcached via PHP (semelhante a Banco de dados MySQL- além do próprio banco de dados, também é necessário instalar a extensão mysql ou mysqli).

Mas a maneira mais fácil é escrever para o hoster. No fastvps, ao solicitar um servidor, o Memcached é instalado por padrão. O principal é indicar quanta memória precisa ser alocada para o cache. Por padrão, é 67 MB. Tenho 4 Gb de RAM, então posso alocar 1 Gb com segurança. Em geral, a maneira mais fácil de estimar quanta memória é necessária para um cache é multiplicar o tamanho do banco de dados por 2. Por exemplo, os bancos de dados em todos os nossos sites pesam 300 MB, então alocamos 600 MB para o cache, ou é melhor levar 1 GB, com margem.

Memcached pode ser visto no phpinfo

Exame

Normalmente o Memcached é executado em localhost e pode ser acessado pela porta 11211
Vejamos as estatísticas

conectar("localhost",11211); print_r($memcache->getStats()); ?>

Resultado:
Variedade
=> 5915
=> 583
=> 1309538445
=> 1.2.2
=> 64
=> 0.000000
=> 0.004000
=> 0
=> 0
=> 0
=> 1
=> 2
=> 2
=> 0
=> 0
=> 0
=> 0
=> 0
=> 7
=> 0
=> 1073741824
=> 1
)

Depois de algum tempo as estatísticas ficarão mais ou menos assim

Variedade
=> 5915
=> 6202245
=> 1315740107
=> 1.2.2
=> 64
=> 3.464216
=> 10.868679
=> 298
=> 17728
=> 120366
=> 1
=> 28654
=> 4
=> 133296
=> 17728
=> 124758
=> 8538
=> 0
=> 11125692
=> 103815319
=> 1073741824
=> 1
)

Parâmetros básicos:
=> 298 - quantos elementos atuais estão no cache.
=> 17728 - quantos elementos totais estavam no cache (incluindo os excluídos)
=> 120366 - quantos bytes estão atualmente no cache
=>1073741824 - quantos bytes estão geralmente disponíveis para o cache (aqui 1 Gb)
=> 124758 - quantas vezes retiramos dados do cache
=> 8538 - quantas vezes tentamos retirar dados do cache, mas eles não estavam lá ou o tempo de vida do cache expirou.

A proporção get_misses/get_hits mostra a eficiência do uso do cache. Quanto menor for, mais eficientemente o cache será usado. Nesse caso, obtemos que 93% dos dados são retirados do cache. Se você get_misses/get_hits=1, então você está fazendo algo errado (provavelmente você está definindo o tempo de vida do cache muito baixo).

estatísticas visuais
O código acima exibe estatísticas de forma seca, como print_r()
Há uma bela saída de estatísticas - phpMemcachedAdmin

Este é um script PHP normal. Você abre no seu site e obtém um lindo design.
Não há necessidade de configurar nada. Por padrão ele se conecta a localhost:11211
Você pode baixá-lo na página oficial.

Exemplos de uso do Memcache

Digamos que temos a string “test111”, queremos armazená-la em cache por 1 dia. Vamos criar algum tipo de chave "key1" para isso.

conectar("localhost",11211); $memcache->set("chave1", "test111", falso, 86400); //cache por 1 dia. $get_result = $memcache->get("chave1"); // obtém dados print_r($get_result); ?>

Vamos complicar um pouco as coisas

get($key)) ( $get_result = $memcache->get($key); print_r($get_result); ) else ( $result = "test222"; // $result é o resultado de alguns cálculos ou uma amostra de o banco de dados $memcache->set($key, $result, false, 86400); echo "cache gravado por 1 dia" ?>

Somente a partir do segundo lançamento deste script veremos nossos dados.

Também esqueci de acrescentar sobre a vida útil do cache. Memcached tem um limite de vida útil de 1 mês. Portanto, se você definir 365 dias, o Memcached simplesmente não os salvará e não apresentará nenhum erro. Portanto, se seus dados não mudam por muito tempo e você deseja definir o tempo de vida máximo, especifique falso
$memcache->set($chave, $resultado, falso, falso);

Recursos de nomenclatura de chaves. É melhor usar md5(key) como chave, porque o comprimento máximo da chave é de 250 caracteres e espaços não podem ser usados. E quando você armazena em cache consultas SQL com uma condição, a chave será como $key = "blog_id_1 WHERE Activity=1 AND ... AND ... LIMIT 10"

Além disso, você também precisa adicionar algum tipo de constante à chave, que determina a qual site o cache pertence.
$chave = md5(PROJETO."chave2"); // onde a constante é PROJECT="site.com"

Se isso não for feito, um segundo site no mesmo servidor poderá substituir os dados do primeiro site com a mesma chave. O fato é que o Memcached não possui autorização, como um banco de dados, por exemplo, então você tem que restringir o acesso desta forma. Resumindo, o Memcached é um grande despejo de pares de valores-chave. Portanto, todos os sites armazenam seu cache em um Memcached. Ao mesmo tempo, não podemos, por exemplo, pegar os últimos 10 elementos registrados (como no banco de dados LIMIT 10). A estrutura do Memcached é extremamente simples, mas com isso obtemos alto desempenho.

Marcação

Como o Memcached é extremamente simples (os dados não estão interligados de forma alguma - existe apenas uma relação chave-valor), surgem algumas dificuldades na prática. Digamos que temos blogs como o Habré. Escrevemos uma postagem e salvamos no cache. Criamos vários pares de valores-chave: um cache para a postagem em si, um cache para o blog em que esta postagem é exibida, um cache para transmissão ao vivo, um cache para exibir postagens de usuários no perfil desse usuário, etc.

$memcache->set("post_id_2211", "dados");
$memcache->set("post_blog_id_11", "dados");
$memcache->set("live_posts", "dados");
$memcache->set("post_user_id_331", "dados");

Mas de repente o moderador deletou a postagem. Precisamos limpar todos os caches associados a esta postagem.

$memcache->delete("post_id_2211");
$memcache->delete("post_blog_id_11");
$memcache->delete("live_posts");
$memcache->delete("post_user_id_331");
…

Resumindo, devido à simplicidade do Memcached, temos que produzir código extra manualmente. Além disso, devemos lembrar constantemente quais caches estão associados a outros caches. A solução para o problema é muito simples. Anexamos uma tag ou várias tags a cada elemento do cache.
Você pode ler mais.

Prática

Na prática, ninguém usa Memcached puro. Geralmente eles usam algum tipo de classe wrapper que suporta marcação. A solução mais comum é ZendCache

Baixe em um arquivo com todos os exemplos
Vamos colocar a classe ZendCache na pasta lib

A estrutura deve ser assim quando vista da raiz
/lib/DklabCache/...
/class/Cache.class.php
/stat.php
/get_post.php
/update_post.php

Classe Wrapper (ou como também é chamada - wrapper) usando ZendCache

array(array("host" => MEMCACHED_HOST, "porta" => MEMCACHED_PORT, "persistente" => falso),), "compressão" => falso,);

self::$instance = novo Cache; self::$instance->memcache = new Dklab_Cache_Backend_TagEmuWrapper(new Zend_Cache_Backend_Memcached($aConfigMem));) else ( return NULL; ) ) return self::$instance;

) função pública get($key) ( return $this->memcache->load($key); ) função pública set($key, $value, $tags=array(), $timeLife=false) ( return $this ->memcache->save($value, $key, $tags, $timeLife); public function delete($key) ( $this->memcache->remove($key); ) public function clean($cMode = Zend_Cache ::CLEANING_MODE_ALL, $tags = array()) ( return $this->memcache->clean($cMode,$tags); ) função pública __construct() ( ) função pública __clone() ( ) ) ?>

Esta é a nossa aula singleton, dizendo

em palavras simples , na primeira chamada é criada uma instância da classe (leitura, uma conexão com o Memcached) e utilizada na próxima chamada. Assim, dentro de um script não criamos conexões desnecessárias e economizamos recursos. A constante CACHE_USE é especificada separadamente na configuração. Usando-o você pode ativar/desativar o cache.

O parâmetro "compression" => false significa que não compactamos os dados no cache. A compactação é necessária para economizar espaço de memória, mas a compactação leva algum tempo. Portanto, se a quantidade de memória não for crítica para você, nós a desabilitamos de forma mais concisa.

Parâmetro "persistente" => false significa desabilitar

conexão permanente

(semelhante a mysql_pconnect())

Aliás, aqui você pode ver como usar vários servidores. Se tivermos 1 servidor

"servidores" => array(array("host" => "localhost", "porta" => 11211, "persistente" => false),)
Por exemplo, temos 3 servidores Memcached
"servidores" => array(array("host" => "11.33.45.11", "porta" => 11211, "persistent" => false), array("host" => "11.33.45.12", "porta " => 11211, "persistente" => falso), array("host" => "11.33.45.13", "porta" => 11211, "persistente" => falso),)
No bom sentido, essas coisas precisam ser movidas da classe para a configuração.

get($key_cache)))( echo "dados retirados do cache"; return $data; ) else ( // encontra a postagem no banco de dados (executa select) //$data = $DB->selectRow("SELECT * FROM post WHERE id=?d", $postID); // para simplificar o exemplo, pegamos um array pronto (o post está vinculado a um blog com ID=3) $data = array("id"=>$ postID, "blog_id"=>3, "title "=>"News 111", "text"=>"algum texto"); Cache->set($key_cache, $ data, array("post_update", "post_update_".$postID, "post_blog_".$data["blog_id"]), 3600*24*10); " ) return $data ) else; return null; ) ) $postID = 25; $post = get_post($postID); print_r($postagem); ?> Queremos fazer um post com id=25. Na primeira vez que você ligar, você verá a mensagem “dados salvos em cache”. Ao ligar novamente, você verá a mensagem “dados retirados do cache”. Agora vamos tentar atualizar a postagem (execute o script update_post.php)query("ATUALIZAR postagem SET blog_id =?d, title=?, text=? WHERE id=?d", $blogID, $title, $text, $postID);

// limpa as tags associadas a esta postagem $Cache = Cache::getInstance();

if (isset($Cache)) ( $Cache->clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG, array("post_update", "post_update_".$postID, "post_blog_".$blogID)); ) return true; ) $postID = 25; update_post($postID, 3, "teste", "teste teste"); ?> Em seguida, executamos o script get_post.php e vemos que não havia dados no cache e os salvamos lá novamente: “dados salvos no cache”. Na verdade, a coisa mais difícil sobre o cache é

colocando as tags corretas

• . Para que quando você atualizar uma postagem, os dados que contêm essa postagem sejam atualizados.
• No exemplo acima, eram tags
• "post_update_".$postID - a postagem em si (geralmente a página de saída da postagem)

"post_blog_".$blogID - página do blog onde uma lista de postagens deste blog é exibida

"post_update" - tag associada à página principal ou lista dos melhores posts

Efeito de pilha de cachorro

Traduzido como “matilha de cães”. Digamos que você tenha uma amostra complexa do banco de dados por 2 segundos. Ainda não está no cache (ou redefinimos o cache). Chega o primeiro usuário, uma solicitação é enviada ao banco de dados, e somente após 2 segundos esses dados aparecerão no cache. Assim, nesses 2 segundos, mais 10 pessoas podem visitar o site, que iniciam mais 10 solicitações iguais e complexas ao banco de dados (já que ainda não há dados no cache e a primeira solicitação ainda está sendo executada). Isso resulta em uma matilha de cães que carrega o servidor.
O código acima não oferece proteção contra o efeito dog-pile. No meu caso, não existe tanto tráfego e solicitações longas.

Há muita informação sobre esse assunto na Internet, mas, apesar disso, muitos o evitam. O objetivo desta postagem é explicar rapidamente os fundamentos da interação com o Memcached.

O que é Memcache e o que ele tem a ver com PHP?

O Memcache foi projetado para armazenar em cache dados que requerem grande quantidade recursos. Esse tipo de dados pode conter qualquer coisa, desde os resultados de uma consulta ao banco de dados até uma parte pesada de um modelo. Memcached não está incluído conjunto básico módulos que acompanham o PHP, porém está disponível no repositório pecl.

Instalação e configuração

Decidi usar o Debian como a distribuição em questão, porque é mais frequentemente usado na criação de servidores web. O módulo Memcached para PHP está disponível no repositório já compilado (php5-memcached), mas descreverei o processo de instalação a partir de código fonte, já que nem todos os repositórios são tão ricos quanto o do Debian.

Instalando o servidor Memcached

#apt-get instalar memcached
Para começar, a seguinte configuração será suficiente para você:

#/etc/memcached.conf
#Memcached funcionará como um demônio
-d
#O log será adicionado lá
arquivo de log /var/log/
#Alocaremos 256 megabytes de RAM para armazenamento
-m 256
#Esta porta escutará
-p 11211
#No futuro é aconselhável mudar
-você não é ninguém
#Ouça localhost
-l 127.0.0.1

#/etc/init.d/memcached reiniciar

Verificando

# netstat -tap | grep memcached
tcp 0 0 localhost:11211 * :* ESCUTE 13036 /

Compile e instale o módulo para PHP

apt-get instalar php5-dev libmemcache-dev

Pecl baixar memcache
tar xzvf memcache-2.2.6.tgz
CD memcache-2.2.6/
phpize && ./ configure --enable-memcache && make
módulos cp/ / usr/ lib/ php5/ 20060613 /

echo "extension=memcache.so" >> / etc/ php5/ apache2/ php.ini
/etc/init.d/apache2 reiniciar

É isso! Não é nada difícil.

Exemplos de uso

1. Operações Básicas

2. //Cria um novo objeto. Você também pode escrever em um estilo processual
3. = novo;
4. -> conectar ("127.0.0.1", 11211) ou morrer ("Não foi possível conectar");
5. //Tenta pegar um objeto com a chave our_var
6. $var_key = @ -> get("nossa_var");
7. if (! vazio ($var_key) )
8. //Se o objeto estiver em cache, imprima seu valor
9. echo $var_key;
10. outro
11. //Se não houver nenhum objeto com a chave our_var no cache, crie-o
12. //Nosso objeto_var será armazenado por 5 segundos e não será compactado
13. -> set ("our_var", data ("G:i:s" ) , false , 5 ) ;
14. //Saída de dados armazenados em cache
15. echo -> get("nossa_var");
16. ->fechar();

Como resultado da execução deste código, a hora será exibida sempre, com precisão de segundos. No entanto, ele será atualizado uma vez a cada 5 segundos até que o cache seja limpo. Este exemplo ilustra as operações mais simples, mas é mais provável que percamos em desempenho do que ganhemos. Afinal, teremos que nos conectar ao servidor todas as vezes...

2. Aumente a produtividade

2.1 Com cache

1. < ? php
2. função CarregarCPU()
3. //Função que deve carregar o processador
4. $imagem = imagemcriar(800, 600);
5. //Cor de fundo branco
6. $cor = imagemcolorallocate($imagem, 255, 255, 255);
7. //Preto
8. $color2 = imagemcolorallocate($imagem, 0, 0, 0);
9. para ($i = 0; $i< 10000 ; $i++ ) {
10. imagesetpixel($imagem, rand (0 , 800 ) , rand (0 ,600 ) , $color2) ;
11. //Joga fora o ponteiro
12. retornar $imagem;
13. //Cria um novo objeto Memcache
14. = novo;
15. //Conecte-se ao nosso servidor
16. -> connect("127.0.0.1" , 11211 ) ou die("Não foi possível conectar" );
17. //Tenta pegar um objeto com a imagem chave
18. $image_bin = -> get("imagem");
19. if (vazio($image_bin) ) (
20. //Se não houver imagem no cache, gere-a e armazene-a em cache
21. imagepng(LoadCPU() ,getcwd() ."/tmp.png" ,9 ) ;
22. $image_bin = file_get_contents(getcwd() ."/tmp.png" );
23. desvincular(getcwd() ."/tmp.png" );
24. -> set("imagem" , $image_bin, false , 30 ) ;
25. //Remove a imagem do cache
26. header("Tipo de conteúdo: imagem/png" );
27. eco $image_bin;
28. //Fecha a conexão com o servidor Memcached
29. -> fechar();
30. ? >

Este exemplo mostra uma função que cria uma imagem de 800x600 e coloca 10.000 pontos nela. Tendo gerado tal imagem uma vez, no futuro apenas a exibiremos na tela sem gerá-la novamente.

2.2 Sem cache

2. função CarregarCPU()
3. //Função que deve carregar o processador
4. //Cria uma imagem 800x600
5. $imagem = imagemcriar(800, 600);
6. //Cor de fundo branco
7. $cor = imagemcolorallocate($imagem, 255, 255, 255);
8. //Preto
9. $cor2 = imagemcolorallocate($imagem, 0, 0, 0);
10. para ($i = 0; $i< 10000 ; $i ++ ) {
11. //Organiza 10.000 pontos em ordem aleatória
12. imagesetpixel($imagem, rand(0, 800), rand(0, 600), $color2);
13. //Joga fora o ponteiro
14. retornar $imagem;
15. //Exibe a imagem sem cache
16. cabeçalho ("Tipo de conteúdo: imagem/png");
17. imagepng (LoadCPU(), "", 9);

Aqui tudo é muito mais simples e familiar: a cada vez geramos a imagem novamente.

Resultados

Testei ambos os scripts quanto ao desempenho. A mesma máquina no primeiro caso produziu 460 respostas por segundo, e no segundo apenas 10. O que era de se esperar.

Alguns recursos mais úteis

addServer - se você tiver vários servidores de cache à sua disposição, poderá criar um cluster adicionando servidores ao pool. Você deve prestar atenção ao parâmetro peso. Indica quanta memória você terá disponível em um determinado servidor.
delete - pelo nome fica claro que este método exclui um objeto com uma determinada chave do cache.
substituir - substitui o valor de um objeto pela chave fornecida. Use-o se precisar alterar o conteúdo de um objeto antes que seu tempo de vida expire.

Resultado final

Do meu ponto de vista, o cache só deve ser usado em recursos altamente carregados. Afinal, toda vez que você se conecta ao servidor Memcached, você perde um tempo precioso, o que provavelmente não será justificado. Já em projetos grandes, é melhor escrever mais linhas de código de uma vez do que fazê-lo com pressa, pensando que seu serviço está mentindo. Além disso, não se esqueça do consumo de memória! Observe que, ao colocar 300 megabytes no cache, você retirou 300 megabytes de RAM...
Concluindo, quero dizer que este artigo não revela todas as delícias da tecnologia, mas espero que estimule você ao autoaperfeiçoamento. Obrigado por ler, querido %username%!

Atualização: Outro ponto interessante. Memcached, existe uma API PHP para libmemcached. E o Memcache, uma biblioteca para php que não usa libmemcached.

O módulo Memcache fornece interfaces procedurais e orientadas a objetos convenientes para o mecanismo de cache memcached. Memcache é um daemon de cache muito eficiente que foi projetado especificamente para reduzir a carga do banco de dados para aplicativos da Web dinâmicos e de alta carga.

O módulo Memcache também fornece um manipulador de sessão. Mais informações sobre o Memcached podem ser encontradas em memcached.org

Em princípio, a descrição da instalação e configuração em russo já está pronta e você pode se familiarizar com ela.

Tenha em mente que você pode armazenar qualquer tipo de dados no cache: variáveis, objetos e arrays, MAS NÃO RECURSOS!

Se um objeto contém uma propriedade - um recurso, por exemplo, uma conexão com um banco de dados, ou contém outro objeto com propriedades semelhantes, então esta situação deve ser tratada separadamente, por exemplo, substituindo o método __sleep() no qual este recurso precisa ser ser “morto” e o método __wakeup() no qual este recurso precisa ser revivido.

Na verdade, todos esses métodos podem ser divididos em 3 grupos:

1. Trabalhando com Valores
2. Trabalhando com servidores e conexões
3. Obtendo informações

Trabalhando com Valores

Os métodos neste grupo permitem que você faça o seguinte:

• Definir valores
• Exclua esses valores
• Substitua esses valores
• Acesse esses valores por chave
• Gerencie a vida útil do valor

Alguns métodos específicos para aumentar e diminuir valores inteiros.

Memcache::set()
Memcache::add()

Permite definir um valor, definir compactação e tempo de vida para esse valor. A única diferença no comportamento desses métodos é que o método Memcache::add retornará FALSE se um valor com a mesma chave já estiver definido.

bool Memcache::adicionar
bool Memcache::definir(string $key , misto $var [, int $flag [, int $expire ]])

• string $key é a chave do valor, usando-a operamos no valor.
• misto $var - valor.
• constantes

conectar("localhost", 11211, 30);

$cache->add("meuprimeiro", 1000, MEMCACHE_COMPRESSED, 15);

$cache->set("meusegundo", 2000, MEMCACHE_COMPRESSED, 15);

Memcache::get()

Retorna o valor solicitado ou FALSE se não tiver êxito ou se o valor com essa chave ainda não tiver sido definido.

Você pode passar um array de chaves de valor, então Memcache::get também retornará um array, que conterá os pares chave-valor encontrados. Avisos!

Se o nome da chave contiver uma barra invertida, então os resultados do trabalho serão imprevisíveis! O Memcached também tem alguns problemas: de acordo com alguns relatos, ele (às vezes)

propenso a erros de buffer overflow , que ocasionalmente resulta na substituição de dados [parciais] e, portanto, torna impossível desserializar estruturas, certifique-se de verificar se Memcache::get retorna um bool, dobule ou long como resultado da recuperação de um array ou objeto, então algo deu errado. corda
Memcache::obter , que ocasionalmente resulta na substituição de dados [parciais] e, portanto, torna impossível desserializar estruturas, certifique-se de verificar se Memcache::get retorna um bool, dobule ou long como resultado da recuperação de um array ou objeto, então algo deu errado.(string $chave [, int &$flags])

• variedade
• (matriz $chaves [, matriz &$flags])

string $key - chave de valor ou uma matriz de chaves cujos valores precisam ser obtidos.

Resultado:

int $flag – o propósito deste parâmetro permanece um mistério para mim. Tentei usar alguns valores inteiros, mas não surtiu nenhum efeito. E a maioria dos exemplos são dados sem usá-lo, do que concluí: você pode trabalhar perfeitamente sem ele :)

conectar("localhost", 11211, 30);

$cache->add("meuprimeiro", 1000, MEMCACHE_COMPRESSED, 15);

$cache->set("meusegundo", 2000, MEMCACHE_COMPRESSED, 15);

print_r($cache->get(array("meuprimeiro","meusegundo")));

Matriz ( => 1000 => 2000)

$cache->set("três", NULL);

Há apenas um sinal de menos - a chave, neste caso, não vai a lugar nenhum

propenso a erros de buffer overflow Memcache::excluir(string $chave [, int $timeout = 0])

• string $key - o valor da chave a ser excluído.
• int $timeout - Este parâmetro também é obsoleto e não é suportado, o padrão é 0 segundos. Não use esta opção.

Memcache::substituir()

Substitua o valor existente.

Memcache::replace() deve ser usado para substituir valor existente. Se um valor com essa chave não existir, Memcache::replace() retornará FALSE. Caso contrário, Memcache::replace() se comporta da mesma forma que Memcache::set(). Você também pode usar a função memcache_replace()

propenso a erros de buffer overflow Memcache::substituir(string $key , misto $var [, int $flag [, int $expire ]])

• string $key - a chave cujo valor precisa ser substituído.
• misto $var - novo valor.
• int $flag - Sinalizador indicando se deve usar compactação (é aqui que entra o Zlib) para o valor armazenado, constantes podem ser usadas
• int $expire – Vida útil do valor (cache). Se for igual a zero, então indefinidamente. Você também pode usar um carimbo de data/hora ou número de segundos desde a hora atual, mas o número de segundos não pode exceder 2.592.000 (30 dias).

conectar("localhost", 11211, 30);

$cache->add("um", 111, 0, 15);

$cache->add("dois", 222, 0, 15);

$cache->add("três", 333, 0, 15);

$cache->replace("três", 777);

print_r($cache->get(array("um","dois","três"))); Matriz ( => 111 => 222 => 777)

• Memcache::incremento()
• Incrementa o valor da chave especificada pelo valor especificado. Se o valor da chave especificada não for numérico e não puder ser convertido em um número, seu valor será alterado para o valor especificado como o segundo parâmetro. Memcache::increment() não cria um elemento se ele ainda não existir.

Não é recomendado usar Memcache::increment() com valores que foram compactados (definidos com a flag MEMCACHE_COMPRESSED) porque haverá surpresas mais tarde quando você tentar obter esses valores usando Memcache::get()

Pessoalmente, verifiquei e não notei nenhuma falha :)

interno

print_r($cache->get(array("um","dois","três"))); Memcache::decremento(string $chave [, int $valor = 1])

• string $key - a chave cujo valor precisa ser decrementado.
• int $value - valor de decréscimo.

Memcache::flush()

Memcache::flush() invalida todos os valores existentes. Memcache::flush() na verdade não libera recursos de memória, apenas marca todos os elementos como obsoletos para que a memória ocupada fique disponível para uso por novos valores. Além disso, você pode usar a função memcache_flush()

bool Memcache::flush(vazio)

O exemplo abaixo não produzirá nada.

conectar("localhost", 11211, 30);

$cache->set("alguém", 111, 0, 5);

$cache->set("algunsdois", 222, 0, 5);

$cache->set("algumaÁrvore", 333, 0, 5); $cache->flush(); //Limpa o cache print_r($cache->get(array("someOne","someTwo","someTree")));

Trabalhando com servidores e conexões. O Memcache pode funcionar com um único servidor ou com um pool (conjunto) de servidores. Se você usar apenas um servidor para servir o cache, para inicializar o trabalho você só precisará criar um objeto de cache e usar o método

Memcache::conectar

Se você for criar um pool de servidores, primeiro precisará criar um objeto de cache e, em seguida, usar o comando

bool $cache->flush(); //Limpa o cache print_r($cache->get(array("someOne","someTwo","someTree")));

Memcache::addServer

adicione o número necessário de servidores a ele.

Memcache::conectar()

Estabelece uma conexão com o servidor Memcached. Uma conexão que foi aberta usando Memcache::connect() será fechada automaticamente quando o script for concluído, mas você pode fechá-la explicitamente usando Memcache::close(). Você também pode usar a função memcache_connect(). Retorna TRUE em caso de sucesso ou FALSE em caso de erro. conectar("localhost", 11211, 30); Memcache::pconnect()

• Este método é semelhante ao Memcache::connect() com a única diferença de que ele estabelece uma conexão persistente. Esta conexão não é fechada quando o script é concluído e Memcache::close() é chamado. Você também pode usar a função memcache_pconnect(). Retorna um objeto Memcache em caso de sucesso ou FALSE em caso de erro.
• misturado
• int $timeout - Limite em segundos para conexão ao daemon. Pense duas vezes antes de alterar o valor padrão de 1 segundo - você poderá perder todos os benefícios do cache se sua conexão demorar muito.

pconnect("localhost", 11211, 30);

Memcache::fechar()

Fecha a conexão com o servidor Memcached. Esta função não fecha conexões persistentes, que são fechadas somente quando o servidor web é desligado/reiniciado. Você também pode usar a função memcache_close().

bool Memcache::fechar(vazio)

Memcache::addServer()

Adiciona um servidor ao pool de conexões. Uma conexão que foi aberta usando Memcache::addServer() será fechada automaticamente quando o script for concluído, ou você pode fechá-la manualmente com Memcache::close(). Você pode usar a função memcache_add_server()

Ao usar Memcache::addServer (em oposição a Memcache::connect() e Memcache::PConnect()), a conexão de rede não é estabelecida até que seja realmente necessária. Dessa forma, não há sobrecarga ao adicionar um grande número de servidores ao pool, mesmo que eles não sejam necessários.

Um pool de servidores oferece maior tolerância a falhas. Quaisquer erros de soquete ou erros do Memcached no nível do servidor (exceto erros de memória) causam realocação de recursos. Erros do cliente, como adicionar uma chave existente, não causarão falhas.

$cache->set("meusegundo", 2000, MEMCACHE_COMPRESSED, 15);

Retorna TRUE em caso de sucesso ou FALSE em caso de erro.

bool O Memcache pode funcionar com um único servidor ou com um pool (conjunto) de servidores.(string $host [, int $port = 11211 [, bool $persistent [, int $weight [, int $timeout [, int $retry_interval [, bool $status [, chamável $failure_callback [, int $timeoutms ]]]] ]]]])

• string $host – host Memcached. Este parâmetro também pode especificar outros transportes como unix:///path/to/memcached.sock, ou seja, use soquetes UNIX; nesse caso, a porta deve ser definida como 0.
• int $port - a porta na qual o Memcached escuta conexões. Defina este parâmetro como 0 se você pretende usar soquetes.
• bool $persistent – ​​Define o uso de uma conexão persistente. O padrão é VERDADEIRO.
• int $weight - Quanto maior o valor, maior a probabilidade de este servidor ser escolhido para armazenar os valores. Aqueles. isso é uma espécie de “peso” do servidor no pool geral, indiretamente também é a carga esperada no servidor.
• int $timeout - Limite em segundos para conexão ao daemon. Pense duas vezes antes de alterar o valor padrão de 1 segundo - você poderá perder todos os benefícios do cache se sua conexão demorar muito.
• string $timeoutms - não descrito.

Obtendo informações

Memcache::getExtendedStats()

Retorna uma matriz associativa bidimensional de estatísticas do servidor. Uma matriz de chaves host:porta do servidor. Os valores contêm parâmetros estatísticos individuais. Servidores com falha terão o valor FALSE. Você também pode usar a função memcache_get_extended_stats()

$cache->set("meusegundo", 2000, MEMCACHE_COMPRESSED, 15);

Este recurso foi adicionado ao Memcache na versão 2.0.0

variedade Memcache::getExtendedStats([string $tipo [, int $slabid [, int $limit = 100 ]]])

E agora uma piada:

O tipo de estatística “cachedump” foi removido do Memcached por motivos de segurança

Exemplo de saída de informações (chamada sem parâmetros):

Matriz ( => Matriz ( => 5179 => 966862 => 1336505233 => 1.4.5 => 64 => 160,302880 => 483,975109 => 6 => 358080 => 13 => 15037476 => 3501979 => 46 => 11507898 => 3529578 => 0 => 0 => 0 => 76 => 0 => 0 => 0 => 0 => 0 => 0 => 0 => 1643906080 => 11298732744 => 67108864 => 1 => 0 => 4 => 0 => 3295454 => 7623 => 3501915 => 0 => 1825755) ...)

Memcache::getServerStatus()

Retorna o status online/offline do servidor. Você também pode usar a função memcache_get_server_status()

$cache->set("meusegundo", 2000, MEMCACHE_COMPRESSED, 15);

Este recurso foi adicionado ao Memcache na versão 2.0.0

print_r($cache->get(array("um","dois","três"))); Memcache::getServerStatus(string $host [, int $porta = 11211])

• string $host – host Memcached.
• int $port - a porta na qual o Memcached escuta conexões.

Memcache::getStats()

Retorna uma matriz associativa com estatísticas do servidor. Uma matriz de chaves correspondentes a parâmetros estatísticos e valores para o valor do parâmetro. Você também pode usar a função memcache_get_stats()

variedade Memcache::getStats s ([ string $ tipo [, int $ slabid [, int $ limite = 100 ]]])

• string $type - Tipo de estatística. Valores válidos: (reset, malloc, mapas, cachedump, lajes, itens, tamanhos). De acordo com a especificação do protocolo Memcached, esses argumentos adicionais “podem ser modificados para conveniência dos desenvolvedores”.
• int $slabid – Usado quando o primeiro parâmetro é definido como “cachedump” especifica o servidor a ser usado para depuração.
• int $limit – Usado quando o primeiro parâmetro é definido como “cachedump” para limitar o número de entradas no dump.

Memcache::getVersion()

Retorna uma string – o número da versão do servidor. Além disso, você pode usar a função memcache_get_version().

propenso a erros de buffer overflow Memcache::getVersion(vazio)

Memcache::setCompressThreshold()

Fornece compactação automática de valores grandes. Você também pode usar a função memcache_set_compress_threshold()

$cache->set("meusegundo", 2000, MEMCACHE_COMPRESSED, 15);

Este recurso foi adicionado ao Memcache na versão 2.0.0

bool Memcache::setCompressThreshold(int $ limite [, float $ min_economia])

• int $threshold – O comprimento mínimo do valor que precisa ser compactado automaticamente.
• float $min_ savings - Define a taxa de compactação. O valor especificado deve estar entre 0 e 1. O valor padrão é 0,2, proporcionando uma economia mínima de 20% na compactação.

Memcache::setServerParams()

Altera os parâmetros do servidor em tempo de execução. Você também pode usar a função memcache_set_server_params().

Retorna TRUE em caso de sucesso ou FALSE em caso de erro.

$cache->set("meusegundo", 2000, MEMCACHE_COMPRESSED, 15);

Este recurso foi adicionado ao Memcache na versão 2.0.0

bool Memcache::setServerParams(string $host [, int $port = 11211 [, int $timeout [, int $retry_interval = false [, bool $status [, chamável $failure_callback ]]]]])

• string $host – host Memcached.
• int $port - a porta na qual o Memcached escuta conexões.
• int $timeout - Limite em segundos para conexão ao daemon. Pense duas vezes antes de alterar o valor padrão de 1 segundo - você poderá perder todos os benefícios do cache se sua conexão demorar muito.
• int $retry_interval - Define a frequência com que um servidor com falha será pesquisado, o padrão é 15 segundos. Definir esse parâmetro como -1 desativa a nova tentativa automática de solicitações.
• bool $status – Marca o servidor como ONLINE. Definir este parâmetro como FALSE e retry_interval -1 permite que o servidor com falha seja mantido em um conjunto de servidores ativos para não afetar os algoritmos de alocação de chaves. As solicitações para este servidor serão distribuídas entre os demais servidores disponíveis. O valor padrão é TRUE, o que significa que o servidor deve ser considerado ONLINE.
• callable $failure_callback - Permite ao usuário especificar uma função de retorno de chamada para ser executada quando um erro for detectado. A função deve receber dois parâmetros, o nome do host e a porta do servidor com falha.

Configurações