A forma com o que o PHP trabalha com referências e gerenciamento de memória não é um assunto muito popular e é compreensível que não seja, se levarmos em conta que na maior parte do tempo como desenvolvedores não precisamos nos preocupar com isso, ademais, o PHP implementa um garbage collector que cuida da contagem das referências e decide o melhor momento de liberar a memória, sem impactar na experiência do desenvolvedor.
Quando falo em “experiência do desenvolvedor”, me refiro ao fato de não precisarmos a todo momento usar unset() para destruir variáveis não mais utilizadas, tampouco passar estruturas mais complexas como objetos ou arrays por referência a todo momento etc. Há raros e específicos casos em que usar referência faz sentido. Como também há raros e específicos casos em que liberar a memória manualmente (sem aguardar o trabalho do garbage collector) faz sentido como, por exemplo, a liberação de um resource para alguma operação subsequente importante que vai consumir um tanto considerável de memória.
A ideia aqui é tentar ao máximo ter uma abordagem leve, de desenvolvedor para desenvolvedor, no sentido de usuários da linguagem. Não tenho a pretenção e nem o conhecimento necessário para explicar o funcionamento interno do PHP e, além do mais, existe gente muito boa e mais preparada pra isso (compartilharei links no final do artigo).
Em suma, esse artigo se propõe a responder as seguintes questões:
- Como um valor é representado internamente no PHP?
- Valores em PHP possuem que semântica? De valor ou de referência?
- Referências? O que são?
- Objetos são passados por referência?
- Se tenho um array com milhões de registros e preciso passá-lo para o argumento de uma função, e agora? Vou dobrar o tanto de memória que estou usando?
Curso PHP - Fundamentos
Conhecer o cursoA estrutura de dado que representa os valores do PHP
No PHP existe uma estrutura de dado elementar chamada zval (zend value), ela é uma estrutura container para qualquer valor arbitrário que se trabalha no PHP:
struct _zval_struct {
zend_value value;
union {
// ...
uint32_t type_info;
} u1;
// ...
};
Para a nossa noção, o mais importante é notarmos que essa estrutura armazena o valor e o tipo desse valor. E, pelo fato de o PHP ser uma linguagem de tipagem dinâmica, o tipo é conhecido apenas em tempo de execução e não em tempo de compilação. Além disso, esse tipo pode mudar durante a execução, por exemplo, um inteiro pode simplesmente virar uma string em um dado momento.
O valor propriamente dito é armazenado na union zend_value (uma union define múltiplos membros de diferentes tipos mas só um deles pode ser ativo por vez):
typedef union _zend_value {
zend_long lval; /* long value */
double dval; /* double value */
zend_refcounted *counted;
zend_string *str;
zend_array *arr;
zend_object *obj;
zend_resource *res;
zend_reference *ref;
zend_ast_ref *ast;
zval *zv;
void *ptr;
zend_class_entry *ce;
zend_function *func;
struct {
uint32_t w1;
uint32_t w2;
} ww;
} zend_value;
Por essa estrutura já podemos inferir os tipos internos das variáveis que declaramos. Objetos são armazenados numa estrutura separada do tipo zend_object, arrays são do tipo zend_array numa implementação de HashTable e assim por diante. Valores simples como inteiros e float são armazenados diretamente na zval, enquanto que valores complexos como strings e objetos são armazenados em estruturas separadas e representados na zval por ponteiros (como pode ser visto em zend_string *str;).
Outra noção refere-se ao fato de que internamente o PHP faz a contagem da quantidade de vezes que um valor é usado por outras variáveis (symbols) e isso é essencial para o gerenciamento da memória por parte do garbage collector, uma vez que esse contador estiver zerado, indica pro GC que a memória desse valor pode ser liberada.
A semântica dos valores
No PHP os valores possuem a semântica de valor, desde que explicitamente não peçamos por uma referência. Ou seja, quando passamos um valor para um argumento de uma função, ou quando atribuímos uma variável a outra, estamos sempre trabalhando em cópias do mesmo valor. Vamos esclarecer esse conceito com exemplos, para que depois possamos adentrar no assunto de referências.
Exemplo:
<?php
$foo = 1;
$bar = $foo;
$foo++;
var_dump($foo, $bar); // int(2), int(1)
$bar aponta para uma zval diferente, apenas com a cópia do valor de $foo. $foo foi incrementada e isso não refletiu em $bar.
Outro exemplo:
<?php
function increment(int $value) : void {
$value++;
}
$value = 1;
increment($value);
echo $value; // 1
O valor de $value dentro do escopo da função é um e fora dela, é outro. Por esse motivo, o que está sendo incrementado é o zval do escopo da função.
Mas, veja bem, cópias não são feitas arbitrariamente sem necessidade. Para valores comuns como inteiros, números de ponto flutuante etc, elas são imediatamente feitas. No entanto, o mesmo não acontece com valores complexos como strings e arrays, por exemplo. O PHP usa o princípio copy-on-write, onde uma deep-copy (duplicação) dos valores é feita apenas antes desses dados serem alterados.
O melhor exemplo para ilustrar isso:
<?php
// Etapa 1: Consumo atual de memória
echo sprintf("1) Mem: %s \n", memory_get_usage());
// Etapa 2: Criando um grande array dinâmicamente
$foo = [];
for ($i = 0; $i < 1000000; $i++) {
$foo[] = random_int(1, 100);
}
echo sprintf("2) Mem: %s \n", memory_get_usage());
// Etapa 3: Atribuindo o array a duas novas variáveis
$bar = $foo;
$baz = $foo;
echo sprintf("3) Mem: %s \n", memory_get_usage());
// Etapa 4: Fizemos uma alteração de escrita no array $bar
$bar[] = 1;
echo sprintf("4) Mem: %s \n", memory_get_usage());
// Etapa 5: Zerando os arrays previamente criados
$foo = [];
$bar = [];
$baz = [];
echo sprintf("5) Mem: %s \n", memory_get_usage());
Resultado:
1) Mem: 395280
2) Mem: 33953920
3) Mem: 33953920
4) Mem: 67512528
5) Mem: 395312
Veja que nas etapas 2 e 3 o consumo de memória permaneceu o mesmo. O senso comum seria imaginar que ele fosse triplicar, uma vez que atribuímos dois novos arrays com o valor de $foo. No entanto, o consumo de memória duplicou apenas na etapa 4, pois alteramos o array $bar, essa operação de escrita fez com que o PHP duplicasse o array para esse zval.
O mesmo comportamento pode ser visto com strings:
<?php
// Etapa 1
echo sprintf("1) Mem: %s \n", memory_get_usage());
// Etapa 2
$string = str_repeat('FOO', 100000);
echo sprintf("2) Mem: %s \n", memory_get_usage());
// Etapa 3
$string2 = $string;
$string3 = $string;
echo sprintf("3) Mem: %s \n", memory_get_usage());
// Etapa 4
$string2 .= 'BAR';
$string3 .= 'BAR';
echo sprintf("4) Mem: %s \n", memory_get_usage());
Resultado:
1) Mem: 393504
2) Mem: 696640
3) Mem: 696640
4) Mem: 1302848
Apenas na etapa 4 tivemos aumento da memória, pois as strings foram modificadas, forçando deep-copy.
Outro exemplo:
<?php
// Etapa 1
echo sprintf("1) Mem: %s \n", memory_get_usage());
// Etapa 2
$string = str_repeat('FOO', 100000);
echo sprintf("2) Mem: %s \n", memory_get_usage());
// Etapa 3
function foo(string $string) {
$string2 = $string;
}
foo($string);
echo sprintf("3) Mem: %s \n", memory_get_usage());
Resultado:
1) Mem: 393400
2) Mem: 696536
3) Mem: 696536
Curso PHP Avançado
Conhecer o cursoReferências no PHP
Referência é um mecanismo que permite que múltiplas variáveis (símbolos) apontem pro mesmo container interno de valor (zval). Referências não são ponteiros como vemos em C ou em Go, por exemplo.
Voltando ao exemplo anterior de $foo e $bar, como podemos fazer para $bar apontar para o mesmo zval que $foo de tal forma que o incremento em $foo reflita em $bar? Aí que entra o operador de referência & na atribuição:
<?php
$foo = 1;
$bar =& $foo;
$foo++;
var_dump($foo, $bar); // int(2), int(2)
Agora, na prática, temos dois símbolos ($foo e $bar) que apontam para o mesmo valor, alterações em um ou em outro refletirão no mesmo container interno de valor. Por esse motivo o incremento de $foo agora refletiu em $bar.
Esse é o exemplo mais elementar para distinguir a semântica de valor da de referência.
Objetos são passados por referência?
Existe a noção entre desenvolvedores e artigos na web de que objetos são passados por referência, mas isso não reflete a realidade. Eles também são passados pela semântica de valor, como qualquer outro valor. Eles apenas possuem um comportamento parecido com “referência” mas que internamente não se trata de referência.
Vejamos esse exemplo:
<?php
class Node
{
// Todo
}
$node1 = new Node();
$node2 = $node1;
xdebug_debug_zval('node1'); // node1: (refcount=2, is_ref=0)=class Node { }
xdebug_debug_zval('node2'); // node2: (refcount=2, is_ref=0)=class Node { }
Nota: A função xdebug_debug_zval() retorna detalhes internos da zval e para ela funcionar, é preciso ter a extensão xdebug instalada.
Na prática, o que temos nesse exemplo, é que as duas variáveis são estruturas (zval) distintas, mas internamente apontam pro mesmo objeto.
O que é diferente de:
<?php
class Node
{
// Todo
}
$node1 = new Node();
$node2 = &$node1;
xdebug_debug_zval('node1'); // node1: (refcount=2, is_ref=1)=class Node { }
xdebug_debug_zval('node2'); // node2: (refcount=2, is_ref=1)=class Node { }
Nesse exemplo, além de ambas as variáveis apontarem pro mesmo objeto, temos explicitamente uma referência, observe que o valor da flag is_ref agora é 1. Isso quer dizer que, $node1 e $node2 apontam para o mesmo zval.
A diferença, a princípio, parece sutil, mas tentemos ver isso na prática. Primeiro um exemplo onde explicitamente pedimos para receber um valor por referência:
<?php
$a = 1;
function change(&$a) {
$a = 2;
}
change($a);
echo $a; // 2
A alteração dentro do escopo da função refletiu no mesmo container interno de valor (zval) da variável $a do escopo do script. Como era esperado.
Agora a dúvida é: se objetos são sempre passados por referência (como é o senso comum), não precisamos usar o operador de referência para receber um objeto nessa mesma função change(), certo?
Vejamos:
<?php
class Node
{
// Todo
}
$node = new Node();
function change($node) {
$node = 10;
}
change($node);
var_dump($node); // class Node#1 (0) { }
Pois bem, se os objetos realmente fossem passados por referência, o valor da variável $node deveria ser 10 e não uma instância da classe Node. Ou seja, quando um objeto é passado para o argumento de uma função/método ou quando é atribuído em outra variável, não temos passagem por referência, o que fica caracterizado é que essas variáveis apenas estão apontando para a mesma estrutura de dado referente ao objeto, o que dá a sensação que está acontecendo passagem por referência.
O que causa essa confusão é esse comportamento:
<?php
class Node
{
public int $count;
}
$node = new Node();
$node->count = 1;
function change(Node $node) {
$node->count = 2;
}
change($node);
echo $node->count; // 2
O resultado é 2, mesmo sem passagem por referência, por causa do comportamento de estarmos trabalhando com o mesmo objeto em memória.
O exemplo abaixo demonstra que estamos lidando com duas estruturas (zval) diferentes, mas que ambas referenciam a mesma estrutura de dado do objeto criado:
<?php
class Node
{
// TODO
}
$node = new Node();
function change(Node $node) {
$nodeFoo = &$node;
xdebug_debug_zval('node'); // node: (refcount=2, is_ref=1)=class Node { }
}
change($node);
xdebug_debug_zval('node'); // node: (refcount=1, is_ref=0)=class Node { }
Veja que dentro do escopo da função já ficou caracterizado que existe referência, mas fora dela, não. Ou seja, se $nodeFoo dentro de change() fosse alterada para 10, refletiria no mesmo zval de $node. Veja:
<?php
class Node
{
// TODO
}
$node = new Node();
function change(Node $node) {
$nodeFoo = &$node;
$nodeFoo = 10; // Reflete no mesmo zval de $node
var_dump($node); // int(10)
}
change($node);
var_dump($node); // class Node#1 (0) { }
Agora, a história muda quando explicitamente recebemos a variável por referência:
<?php
class Node
{
// Todo
}
$node = new Node();
function change(&$node) {
$node = 10; // Reflete no mesmo zval da variável $node fora desse escopo
}
change($node);
var_dump($node); // int(10)
Por fim, um exemplo de variáveis que não se referenciam, mas que apontam para o mesmo valor interno em memória até que uma operação de escrita seja realizada, aí é feita uma deep-copy:
<?php
$string = str_repeat('FOO ', 4);
xdebug_debug_zval('string'); // string: (refcount=1, is_ref=0)='FOO FOO FOO FOO '
$string2 = $string;
xdebug_debug_zval('string'); // string: (refcount=2, is_ref=0)='FOO FOO FOO FOO '
$string3 = $string;
xdebug_debug_zval('string'); // string: (refcount=3, is_ref=0)='FOO FOO FOO FOO '
$string3 .= 'BAR';
xdebug_debug_zval('string'); // string: (refcount=2, is_ref=0)='FOO FOO FOO FOO '
Observe que depois que $string3 fez uma operação de escrita o refcount do valor de $string foi decrementado.
Outro exemplo genérico:
<?php
class Foo {
public $index;
}
$a = new Foo();
$b = $a;
$c = &$b;
$c->index = 10;
echo "({$a->index}, {$b->index}, {$c->index})" . PHP_EOL; // (10, 10, 10)
$c = "Hello";
echo "({$a->index}, {$b}, {$c})"; // (10, Hello, Hello)
Na prática temos:
Todos os símbolos apontam pro mesmo objeto, no entanto, $c é referência de $b, alterações feitas em $c refletirão na mesma zval de $b, mantendo $a intacta.
Em que momento devo usar referências?
As funções de sorting de arrays do PHP os recebem por referência, por exemplo:
sort ( array &$array [, int $sort_flags = SORT_REGULAR ] ) : bool
Sempre que você ver na assinatura de uma função &$var, significa que está recebendo por referência e que, portanto, vai trabalhar na mesma zval da variável informada.
E usar referências não é sobre performance, dependendo do uso, pode piorá-la. Usar referências é mais sobre lidar melhor com a memória, como no caso da função acima, não faria sentido duplicar o array inteiro só para aplicar o algoritmo de sorting.
Mas, no geral, a regra é que você dificilmente vai usar com frequência operações com referências. Usa-se referências quando realmente existe um objetivo muito bem definido, portanto, não se preocupe em querer “otimizar” o seu código pra usar referências, pois é bem possível que você não precisa delas.
O que mais posso fazer com referências?
Você pode ver todas as sintaxe possíveis para se usar referências no PHP através desse link da documentação oficial.
Palavras finais
Sumarizando o que foi visto nesse artigo:
- PHP usa a semântica de valor;
- Objetos não são passados por referência;
- Valores complexos como arrays e strings são apenas duplicados quando alterados (usa-se o princípio copy-on-write);
- Referências não deixam o código mais performático, se mal utilizadas, podem é deixar mais lento, devido aos vários apontamentos que precisam ser feitos. Referências são usadas em casos bem específicos em que o desenvolvedor tem a exata noção do comportamento que ele espera ter;
- O desenvolvedor não precisa na maior parte do tempo se preocupar com memória (a não ser que vá trabalhar com grandes data sets, mas aí pode-se estudar o uso de generators no PHP ou alguma outra estratégia);
Não é nada fácil entender a figura completa desse conjunto de pecinhas, mas caso você tenha interesse em se aprofundar, recomendo a leitura dos artigos:
Até a próxima!
