overwrite the stack?

Harold,

I've run your code and I'm curious to know how you know that the line
    Integer obj3 = new Integer(333);
causes the stack to be overwritten.

Even though the Integer obj3 is never used in the code, that line 
changes the code's behavior (commenting it out changes the output of the 
last print statement) at least in my tests running Java 1.5 from Eclipse 
3.1.

Rich

Harold Meder wrote:
> OK.  What happens if I am working with an object that I got from a weak 
> reference when the garbage collector comes around?
> 
> No problem:  To work with the object, you need to ask the weak reference 
> for a strong reference.  It is with this strong reference that you can 
> work with it.  So, even though everyone else has giving up their strong 
> reference, the object survives since you still have a strong reference.
> 
> So, when do you actually give up your strong reference?  Phillip says, 
> "Try it!"
> 
> You better set your strong reference = null.
> Just going out of scope is not enough.
> 
> Your strong reference stays on your stack until it is overwritten.
> 
> That means that any thread's stack can hold a strong reference that you 
> thought has long gone out of scope.  The garbage collector will not 
> collect it until the stack is overwritten. 
> 
> This might suggest that a pooled thread can hold strong references on 
> its stack until it is started up again and overwrites its stack.  Or is 
> a thread's stack garbage collected when it stops?  I will let someone 
> else try it.
> 
> Note that this stowaway strong reference hiding on your stack may be a 
> Collection containing thousands of strong references preventing the 
> garbage collector from doing what you might think it should have done a 
> long time ago.  
> 
> This problem is independent of the use of weak references.  This is a 
> problem that is happening in your code … if you don't set your (strong) 
> references to = null.
> 
> Aren't you ashamed of pointing out that there was no need to set 
> references = null before they go out of scope?
> 
> The appended code produces the following output.
> 
> ----------
> 
> Both Weak References survive while Strong References survive on stack.
> (1)111, 222
> Can't garbage collect it while it has a strong reference.
> (100) 111, 222
> Can't garbage collect, even when it Strong Reference goes out of scope.
> (100) 111, 222
> Can garbage collect, when Strong Reference set to null.
> (1) 111, null
> At last!  If the stack is overwritten, the last Strong Reference is gone.
> (1) null, null
> 
> ----------
> 
> import java.lang.ref.WeakReference;
> 
> public class RefTest
> {
>     public static void main (String[] args)
>     {
>         WeakReference <Integer> wr1;
>         WeakReference <Integer> wr2;
>         {
>             Integer obj1 = new Integer (111);
>             Integer obj2 = new Integer (222);
>             wr1 = new WeakReference <Integer> (obj1);
>             wr2 = new WeakReference <Integer> (obj2);
>         }
>         // obj is out of scope,
>         // but the garbage collector is lazy.
>         System.gc (); Thread.yield ();
>         System.out.println (
> "Both Weak References survive " +
> "while Strong References survive on stack.\n(1)" +
> wr1.get () + ", " + wr2.get ());
>         
>         int i = 0;
>         Integer newStrongRef2;
>         {
>             // Before we loose the objects,
>             // let's save them with new Strong Referenences.
>             Integer newStrongRef1 = wr1.get ();
>             newStrongRef2 = wr2.get ();
>             while (wr1.get () != null)
>             {
>                 System.gc (); Thread.yield ();
>                 if ( ++i > 99) break;
>             }
>             System.out.println (
> "Can't garbage collect it while it has a strong reference.\n("
> + i + ") " +
> wr1.get () + ", " + wr2.get ());
>         }
>         
>         i = 0;
>         {
>             // OK, with newStrongRef1 out of scope,
>             // but
>             while ( wr1.get () != null)
>             {
>                 System.gc (); Thread.yield ();
>                 if ( ++i > 99) break;
>             }
>             System.out.println (
> "Can't garbage collect, " +
> "even when it Strong Reference goes out of scope.\n("
> + i + ") " +
> wr1.get () + ", " + wr2.get ());
> 
>             i = 0;
>             newStrongRef2 = null;
>             {
>                 // OK, with newStrongRef1 out of scope,
>                 // but
>                 while (wr2.get () != null)
>                 {
>                     System.gc (); Thread.yield ();
>                     if ( ++i > 99) break;
>                 }
>                 System.out.println (
> "Can garbage collect, " +
> "when Strong Reference set to null.\n("
> + i + ") " +
> wr1.get () + ", " + wr2.get ());
>             }
>         }
> 
>         Integer obj3 = new Integer(333);
>         i = 0;
>         {
>             while (wr1.get () != null)
>             {
>                 System.gc (); Thread.yield ();
>                 if ( ++i > 999) break;
>             }
>             System.out.println (
> "At last!  If the stack is overwritten, " +
> "the last Strong Reference is gone.\n("
> + i + ") " +
> wr1.get () + ", " + wr2.get ());
>         }
>     }
> 
> }
> 
>