PHP 5 garbage collection
13 September 2004, by Karl Bunyan
The object-oriented features of PHP 5 are a really positive step forward for the language. One of the biggest improvements, to my mind, is that you no longer have to choose to pass things around by reference with a liberal smattering of '&' symbols: references are now the default way of passing objects. 
The object-oriented features of PHP 5 are a really positive step forward for the language. One of the biggest improvements, to my mind, is that you no longer have to choose to pass things around by reference with a liberal smattering of ‘&’ symbols: references are now the default way of passing objects. One problem I have come across, though, is that the reference counting feature of PHP’s garbage collection (http://www.zend.com/zend/art/ref-count.php) means that objects with mutual references are not deleted even when I thought the object was out of existence. E.g:
class ParentObject()
{
protected $childObject;
function __construct()
{
$this->childObject = new ChildObject($this);
}
}
class ChildObject()
{
protected $parentObject;
//Pass in a reference to the parent
//object and store it internally
function __construct($parentObject)
{
$this->parentObject = $parentObject;
}
}
Then if I call $foo = new ParentObject(); then it automatically creates a child object with a reference to the parent. The parent also keeps a reference to its child. If I then unset($foo); the two objects are still referencing each other and so are not deleted. The only way I’ve found to clear this is to create a new method (which I call destroy()) to delete references to the child. Calling destroy() on the parent first calls destroy() on its child, which dereferences the parent, and then the parent dereferences the child. So the classes are now:
class ParentObject()
{
protected $childObject;
function __construct()
{
$this->childObject = new ChildObject($this);
}
public function destroy()
{
$this->childObject->destroy();
unset($this->childObject);
}
}
class ChildObject()
{
protected $parentObject;
//Pass in a reference to the parent object
//and store it internally
function __construct($parentObject)
{
$this->parentObject = $parentObject;
}
public function destroy()
{
unset($this->parentObject);
}
}
And I have to call
$foo->destroy();
unset($foo);
To clear the thing out completely. This can cause a number of problems which I won’t go into in detail here (they occur in more complex design patterns), but suffice to say that there are a number of occassions where I don’t necessarily want to destroy a child at the same time as a parent, or vice-versa. E.g. a child references multiple parents. The end result is that I’m writing code to deal with garbage collection where it is having a big effect on memory and just leaving it out where it doesn’t seem to make as much difference. This suffices for a known set of data but doesn’t feel very satisfactory in terms of future-proofing. I would appreciate it if anyone else has a better way of doing things.
September 13, 2004 at 8:06 pm
Filed in: PHP, Programming
No comments