Find Usages Diff Raw Download HTML Widget Stack Overflow Q&A
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
1. Understanding Java's Reference classes: SoftReference, WeakReference, and PhantomReference
Can someone explain the difference between the three Reference classes (or post a link to a nice explanation)? SoftReference > WeakReference > PhantomReference, but when would I use each one? Why is there a WeakHashMap but no SoftHashMap or PhantomHashMap? And if I use the following code... WeakReference<String> ref = new WeakReference<String>("Hello!"); if (ref != null) { ...
2. It's possible see all the references to an object in execution time?
Is there a way to see all the references to an object in execution time? I'm using Netbeans, this feature exist in it? EDIT: No problem in using profilers to do this, I only need know the references, no matters how.
3. Default threads like, DestroyJavaVM, Reference Handler, Signal Dispatcher,
Working on a profiler of my own, I would like to explain what I see. There are some default threads which always appear, even in the simplest program: DestroyJavaVM Signal Dispatcher Finalizer Reference Handler Although their names are quite self-documenting, I would like to get a little bit more information. It seems these threads are not documented, does someone know a source to dig for t...
4. Howto delete all object pointer in java
is there an elegant way in Java to set all existing object-pointers to null? I want an object to be deleted, but it is registered in several places an Event Listener.
5. Java: Is there a class which wraps a reference and provides a getter and setter?
Sorry for the stupid question. I'm very sure, that the Java API provides a class which wraps a reference, and provides a getter and a setter to it. class SomeWrapperClass<T> { private T obj; public T get(){ return obj; } public void set(T obj){ this.obj=obj; } } Am I right? Is there something like this in the Java API? Thank you. Yes, I could write it y myself, but why...
6. How to achieve differentiation between undef and null values for java data types
What is the common approach followed in applications if we have to differentiate between 'undefined' value and 'null' value for properties in a class? For example, let's say we have a class A public class A { Integer int1; Boolean bool1; Double doub1; String str1; } In the code, we would like to differentiate if each property of A is either set or not set (null is a VALID value to set)....
7. What is hard reference in java?
When I was studying about permgen, I came across the term hard reference. I don't know what is meant by hard reference. Can anyone explain or give me some tutorials about that please?
8. Suggest a name for a class which has an expiry time
"There are only two hard things in Computer Science: cache invalidation and naming things" - Phil Karlton. I am writing a class which wraps an object with an expiry timestamp. The API looks like this: class ObjectWrapperWithExpiry<T> { private T obj; private long expiryTimestamp; ObjectWrapperWithExpiry(T obj, int ttl) { this.obj = obj; expiryTimestamp = System...
9. Android-Java- converting a WeakReference to a normal Bitmap
Ive been working on an app for a while that uses lots of Bitmaps and Ive gotten it to the point where its working really well on most devices that Ive tested it on except for a newer droid bionic that runs 2.3.4 I get an out of memory error and I can see the heap growing in the logcat too. So far Ive tried re-sizing the bitmaps with different techniques which works great for every other device...
10. Mixing different reference types in one collection
SoftReference, WeakReference, PhantomReference may be used to customize the process of garbage collection. All of them extend Reference<T> therefore it is possible to mix them in single collection. Hard references (most common ones) do no extend Reference<T> therefore it is not possible to mix hard and other types of references in one collection. Am I right and we should put CustomR... 
1
  /*
2
   * Copyright 1997-2006 Sun Microsystems, Inc.  All Rights Reserved.
3
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
   *
5
   * This code is free software; you can redistribute it and/or modify it
6
   * under the terms of the GNU General Public License version 2 only, as
7
   * published by the Free Software Foundation.  Sun designates this
8
   * particular file as subject to the "Classpath" exception as provided
9
   * by Sun in the LICENSE file that accompanied this code.
10
  *
11
  * This code is distributed in the hope that it will be useful, but WITHOUT
12
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14
  * version 2 for more details (a copy is included in the LICENSE file that
15
  * accompanied this code).
16
  *
17
  * You should have received a copy of the GNU General Public License version
18
  * 2 along with this work; if not, write to the Free Software Foundation,
19
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20
  *
21
  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22
  * CA 95054 USA or visit www.sun.com if you need additional information or
23
  * have any questions.
24
  */
25
 
26
 package java.lang.ref;
27
 
Abstract base class for reference objects. This class defines the operations common to all reference objects. Because reference objects are implemented in close cooperation with the garbage collector, this class may not be subclassed directly.

Author(s):
Mark Reinhold
Since:
1.2
39
 
40
 
41
 public abstract class Reference<T> {
42
 
43
     /* A Reference instance is in one of four possible internal states:
44
      *
45
      *     Active: Subject to special treatment by the garbage collector.  Some
46
      *     time after the collector detects that the reachability of the
47
      *     referent has changed to the appropriate state, it changes the
48
      *     instance's state to either Pending or Inactive, depending upon
49
      *     whether or not the instance was registered with a queue when it was
50
      *     created.  In the former case it also adds the instance to the
51
      *     pending-Reference list.  Newly-created instances are Active.
52
      *
53
      *     Pending: An element of the pending-Reference list, waiting to be
54
      *     enqueued by the Reference-handler thread.  Unregistered instances
55
      *     are never in this state.
56
      *
57
      *     Enqueued: An element of the queue with which the instance was
58
      *     registered when it was created.  When an instance is removed from
59
      *     its ReferenceQueue, it is made Inactive.  Unregistered instances are
60
      *     never in this state.
61
      *
62
      *     Inactive: Nothing more to do.  Once an instance becomes Inactive its
63
      *     state will never change again.
64
      *
65
      * The state is encoded in the queue and next fields as follows:
66
      *
67
      *     Active: queue = ReferenceQueue with which instance is registered, or
68
      *     ReferenceQueue.NULL if it was not registered with a queue; next =
69
      *     null.
70
      *
71
      *     Pending: queue = ReferenceQueue with which instance is registered;
72
      *     next = Following instance in queue, or this if at end of list.
73
      *
74
      *     Enqueued: queue = ReferenceQueue.ENQUEUED; next = Following instance
75
      *     in queue, or this if at end of list.
76
      *
77
      *     Inactive: queue = ReferenceQueue.NULL; next = this.
78
      *
79
      * With this scheme the collector need only examine the next field in order
80
      * to determine whether a Reference instance requires special treatment: If
81
      * the next field is null then the instance is active; if it is non-null,
82
      * then the collector should treat the instance normally.
83
      *
84
      * To ensure that concurrent collector can discover active Reference
85
      * objects without interfering with application threads that may apply
86
      * the enqueue() method to those objects, collectors should link
87
      * discovered objects through the discovered field.
88
      */
89
 
90
     private T referent;         /* Treated specially by GC */
91
 
92
     ReferenceQueue<? super T> queue;
93
 
94
     Reference next;
95
     transient private Reference<T> discovered;  /* used by VM */
96
 
97
 
98
     /* Object used to synchronize with the garbage collector.  The collector
99
      * must acquire this lock at the beginning of each collection cycle.  It is
100
     * therefore critical that any code holding this lock complete as quickly
101
     * as possible, allocate no new objects, and avoid calling user code.
102
     */
103
    static private class Lock { };
104
    private static Lock lock = new Lock();
107
    /* List of References waiting to be enqueued.  The collector adds
108
     * References to this list, while the Reference-handler thread removes
109
     * them.  This list is protected by the above lock object.
110
     */
111
    private static Reference pending = null;
113
    /* High-priority thread to enqueue pending References
114
     */
115
    private static class ReferenceHandler extends Thread {
117
        ReferenceHandler(ThreadGroup g, String name) {
118
            super(g, name);
119
        }
121
        public void run() {
122
            for (;;) {
124
                Reference r;
125
                synchronized () {
126
                    if ( != null) {
127
                        r = ;
128
                        Reference rn = r.next;
129
                         = (rn == r) ? null : rn;
130
                        r.next = r;
131
                    } else {
132
                        try {
133
                            .wait();
134
                        } catch (InterruptedException x) { }
135
                        continue;
136
                    }
137
                }
139
                // Fast path for cleaners
140
                if (r instanceof Cleaner) {
141
                    ((Cleaner)r).clean();
142
                    continue;
143
                }
145
                ReferenceQueue q = r.queue;
146
                if (q != .) q.enqueue(r);
147
            }
148
        }
149
    }
151
    static {
152
        ThreadGroup tg = Thread.currentThread().getThreadGroup();
153
        for (ThreadGroup tgn = tg;
154
             tgn != null;
155
             tg = tgn, tgn = tg.getParent());
156
        Thread handler = new ReferenceHandler(tg, "Reference Handler");
157
        /* If there were a special system-only priority greater than
158
         * MAX_PRIORITY, it would be used here
159
         */
160
        handler.setPriority(.);
161
        handler.setDaemon(true);
162
        handler.start();
163
    }
166
    /* -- Referent accessor and setters -- */

    
Returns this reference object's referent. If this reference object has been cleared, either by the program or by the garbage collector, then this method returns null.

Returns:
The object to which this reference refers, or null if this reference object has been cleared
176
    public T get() {
177
        return this.;
178
    }

    
Clears this reference object. Invoking this method will not cause this object to be enqueued.

This method is invoked only by Java code; when the garbage collector clears references it does so directly, without invoking this method. 

187
    public void clear() {
188
        this. = null;
189
    }
192
    /* -- Queue operations -- */

    
Tells whether or not this reference object has been enqueued, either by the program or by the garbage collector. If this reference object was not registered with a queue when it was created, then this method will always return false.

Returns:
true if and only if this reference object has been enqueued
203
    public boolean isEnqueued() {
204
        /* In terms of the internal states, this predicate actually tests
205
           whether the instance is either Pending or Enqueued */
206
        synchronized (this) {
207
            return (this. != .) && (this. != null);
208
        }
209
    }

    
Adds this reference object to the queue with which it is registered, if any.

This method is invoked only by Java code; when the garbage collector enqueues references it does so directly, without invoking this method.

Returns:
true if this reference object was successfully enqueued; false if it was already enqueued or if it was not registered with a queue when it was created
222
    public boolean enqueue() {
223
        return this..enqueue(this);
224
    }
227
    /* -- Constructors -- */
229
    Reference(T referent) {
230
        this(referent, null);
231
    }
233
    Reference(T referent, ReferenceQueue<? super T> queue) {
234
        this. = referent;
235
        this. = (queue == null) ? . : queue;
236
    }
New to GrepCode? Check out our FAQ X