__destruct() order

[pimox]

I am a bit confused about the order how the objects are destructed in PHP 5.0.3. The doc says

The destructor method will be called as soon as all references to a particular object are removed or when the object is explicitly destroyed.

But the following example

<?php
class UtilityClass {
    private $myID = 123;
    public function __construct ( ) {
        echo "UtilityClass($this->myID).__construct()<br>";
    }
    public function __destruct ( ) {
        echo "UtilityClass($this->myID).__destruct()<br>";
    }
    public function printOut ( $outValue ) {
        echo "UtilityClass($this->myID).printOut ($outValue)<br>";
    }
} // Utility Class

class TaskClass {
    private $utilityObj;
    public function __construct ( $UtilityClassObject ) {
        echo "TaskClass.__construct(" . get_class($UtilityClassObject) . ")<br>"
;
        $this->utilityObj = $UtilityClassObject;
    }
    public function __destruct ( ) {
        echo "TaskClass.__destruct()<br>";
        $this->utilityObj->printOut ("are you still there?");
    }
    public function doWork ( ) {
        $this->utilityObj->printOut ("Work is done.");
    }
} // TaskClass

$utility = new UtilityClass ( );
$task = new TaskClass ( $utility );

$task->doWork ( );

?>

produces

UtilityClass(123).__construct()
TaskClass.__construct(UtilityClass)
UtilityClass(123).printOut (Work is done.)
UtilityClass(123).__destruct()
TaskClass.__destruct()
UtilityClass(123).printOut (are you still there?)

From my opinion, not all references to UtilityClass are removed and still its destruct method is called before TaskClass's destruct method.

But maybe I am worrying for nothing, since the UtilityClass seems to be still there ? How to explicitly destroy an object ?

Canne

[Weedpacket]

It's at least partly to do with the fact that this is occurring at the end of the script. Normal reference counting rules are held in abeyance; partly for efficiency reasons and partly because otherwise the cleanup process could get stuck on things like circular references. When the script terminates, the internal object list is just cranked through from beginning to end, calling all of the destructors found; the objects are retained though, in case there are other objects whose destructors are still to be called that are referring to them. This is quicker and more effective than chasing references, and any transient problems caused by objects still sitting around after they're destroyed goes unnoticed, because the program state is just as consistent afterwards as it was beforehand - only now all the objects are gone. But that's okay, because everything else is gone as well.

To explicitly remove a (reference to) an object, $object = null; or unset($object); . Consider

$utility = new UtilityClass ( );
$task = new TaskClass ( $utility );
$task->doWork ( );
$task = null;
echo '$utility is still around.';

and

$utility = new UtilityClass ( );
$task = new TaskClass ( $utility );
$utility = null;
$task->doWork ( );
$task = null;
echo 'All gone!';

In short, word from Andi Guttmans is

A VERY important implication is that you cannot, and must not rely in any way on the order of destruction during shutdown. It runs in no particular order. That means that by the time the destructor for your object $foo is called, a reference to some other object $bar may already be post-destruction. Note that it will still be ‘intact’ and accessible in the sense that if you access it - there won’t be crashes. However, if this object does indeed have a destructor, it can be considered semantically wrong to touch this object at this point.

[pimox]

Thank you for your insight.

Originally posted by Weedpacket - [snip]Note that at the end of your script there are two references to the UtilityClass object - one of which was created before the TaskClass object.[snip]

After having read the excellent post (of Richard) on PHP5 Doc's Classes and Objects Basics, with this great graph I was reasoning that the object itself gets destroyed only once all the references to it have been disappeared. Therefore I use references to extrenal objects in some of my destructors. Although they appear to work (!), logically they should throw an exception.

To conclude, the object destruction order is not predictable in PHP5. Therefore one cannot use references to other objects within a destructor.

Canne

[Weedpacket]

Originally posted by pimox
To conclude, the object destruction order is not predictable in PHP5. Therefore one cannot use references to other objects within a destructor.

And as I pointed out, this is because you were waiting until script termination to run your destructors, and that is handled as a special case. If you look at the graph you linked to, you'll notice that $instance is being unset explicitly.

[pimox]

Originally posted by Weedpacket
And as I pointed out, this is because you were waiting until script termination to run your destructors, and that is handled as a special case. If you look at the graph you linked to, you'll notice that $instance is being unset explicitly.

I took note of your post and started to unset explicitly my objects so that the "UtilityClass" type of objects are unset last, just before the script ends. That was the cure for my problems.

Thanks,
Canne

[anroy]

pimox wrote:

I am a bit confused about the order how the objects are destructed in PHP 5.0.3. The doc says

The destructor method will be called as soon as all references to a particular object are removed or when the object is explicitly destroyed.

I too struggle with this area. I come from a C++ background and am a newbie at web programming.

What does it mean to say "all references to a particular object are removed"? Does it just mean the last instance of a object's variable being used? But PHP is interpreted (another fact that is taking taking a while to get used to 🙂 ) so how would the interpreter know when a variable is no longer used? You don't know what code follows.

So would it be a case of all variables just being unset when a program ends and destruction of objects just naturally happening at that time?

[Weedpacket]

anroy wrote:

so how would the interpreter know when a variable is no longer used? You don't know what code follows.

It keeps count. As soon as the count drops to zero, it's no longer accessible to anything in the program (becase nothing is referencing it), so it's discarded.

anroy wrote:

...all variables just being unset when a program ends...

or go out of scope. Or are unset() explicitly. Or reassigned to something else.