jdk/src/java.base/share/classes/java/lang/ref/Reference.java
author twisti
Tue, 22 Dec 2015 13:41:12 -0800
changeset 35257 87ae1d0f6948
parent 35254 ba6a26f39b86
parent 34716 7477a052aecc
child 35641 da165fd9c886
permissions -rw-r--r--
Merge
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     1
/*
32100
8a0db19f4e84 8059036: Implement Diagnostic Commands for heap and finalizerinfo
dsamersoff
parents: 31671
diff changeset
     2
 * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
90ce3da70b43 Initial load
duke
parents:
diff changeset
     4
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
90ce3da70b43 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 2
diff changeset
     7
 * published by the Free Software Foundation.  Oracle designates this
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     8
 * particular file as subject to the "Classpath" exception as provided
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 2
diff changeset
     9
 * by Oracle in the LICENSE file that accompanied this code.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    10
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    11
 * This code is distributed in the hope that it will be useful, but WITHOUT
90ce3da70b43 Initial load
duke
parents:
diff changeset
    12
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
90ce3da70b43 Initial load
duke
parents:
diff changeset
    13
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
90ce3da70b43 Initial load
duke
parents:
diff changeset
    14
 * version 2 for more details (a copy is included in the LICENSE file that
90ce3da70b43 Initial load
duke
parents:
diff changeset
    15
 * accompanied this code).
90ce3da70b43 Initial load
duke
parents:
diff changeset
    16
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    17
 * You should have received a copy of the GNU General Public License version
90ce3da70b43 Initial load
duke
parents:
diff changeset
    18
 * 2 along with this work; if not, write to the Free Software Foundation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    19
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    20
 *
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 2
diff changeset
    21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 2
diff changeset
    22
 * or visit www.oracle.com if you need additional information or have any
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 2
diff changeset
    23
 * questions.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    24
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    25
90ce3da70b43 Initial load
duke
parents:
diff changeset
    26
package java.lang.ref;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    27
35254
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
    28
import jdk.internal.vm.annotation.DontInline;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    29
import sun.misc.Cleaner;
32834
e1dca5fe4de3 8137056: Move SharedSecrets and interface friends out of sun.misc
chegar
parents: 32649
diff changeset
    30
import jdk.internal.HotSpotIntrinsicCandidate;
e1dca5fe4de3 8137056: Move SharedSecrets and interface friends out of sun.misc
chegar
parents: 32649
diff changeset
    31
import jdk.internal.misc.JavaLangRefAccess;
e1dca5fe4de3 8137056: Move SharedSecrets and interface friends out of sun.misc
chegar
parents: 32649
diff changeset
    32
import jdk.internal.misc.SharedSecrets;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    33
90ce3da70b43 Initial load
duke
parents:
diff changeset
    34
/**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    35
 * Abstract base class for reference objects.  This class defines the
90ce3da70b43 Initial load
duke
parents:
diff changeset
    36
 * operations common to all reference objects.  Because reference objects are
90ce3da70b43 Initial load
duke
parents:
diff changeset
    37
 * implemented in close cooperation with the garbage collector, this class may
90ce3da70b43 Initial load
duke
parents:
diff changeset
    38
 * not be subclassed directly.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    39
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    40
 * @author   Mark Reinhold
90ce3da70b43 Initial load
duke
parents:
diff changeset
    41
 * @since    1.2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    42
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    43
90ce3da70b43 Initial load
duke
parents:
diff changeset
    44
public abstract class Reference<T> {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    45
90ce3da70b43 Initial load
duke
parents:
diff changeset
    46
    /* A Reference instance is in one of four possible internal states:
90ce3da70b43 Initial load
duke
parents:
diff changeset
    47
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    48
     *     Active: Subject to special treatment by the garbage collector.  Some
90ce3da70b43 Initial load
duke
parents:
diff changeset
    49
     *     time after the collector detects that the reachability of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
    50
     *     referent has changed to the appropriate state, it changes the
90ce3da70b43 Initial load
duke
parents:
diff changeset
    51
     *     instance's state to either Pending or Inactive, depending upon
90ce3da70b43 Initial load
duke
parents:
diff changeset
    52
     *     whether or not the instance was registered with a queue when it was
90ce3da70b43 Initial load
duke
parents:
diff changeset
    53
     *     created.  In the former case it also adds the instance to the
90ce3da70b43 Initial load
duke
parents:
diff changeset
    54
     *     pending-Reference list.  Newly-created instances are Active.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    55
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    56
     *     Pending: An element of the pending-Reference list, waiting to be
90ce3da70b43 Initial load
duke
parents:
diff changeset
    57
     *     enqueued by the Reference-handler thread.  Unregistered instances
90ce3da70b43 Initial load
duke
parents:
diff changeset
    58
     *     are never in this state.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    59
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    60
     *     Enqueued: An element of the queue with which the instance was
90ce3da70b43 Initial load
duke
parents:
diff changeset
    61
     *     registered when it was created.  When an instance is removed from
90ce3da70b43 Initial load
duke
parents:
diff changeset
    62
     *     its ReferenceQueue, it is made Inactive.  Unregistered instances are
90ce3da70b43 Initial load
duke
parents:
diff changeset
    63
     *     never in this state.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    64
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    65
     *     Inactive: Nothing more to do.  Once an instance becomes Inactive its
90ce3da70b43 Initial load
duke
parents:
diff changeset
    66
     *     state will never change again.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    67
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    68
     * The state is encoded in the queue and next fields as follows:
90ce3da70b43 Initial load
duke
parents:
diff changeset
    69
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    70
     *     Active: queue = ReferenceQueue with which instance is registered, or
90ce3da70b43 Initial load
duke
parents:
diff changeset
    71
     *     ReferenceQueue.NULL if it was not registered with a queue; next =
90ce3da70b43 Initial load
duke
parents:
diff changeset
    72
     *     null.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    73
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    74
     *     Pending: queue = ReferenceQueue with which instance is registered;
10895
7434064aba55 4243978: (ref) Race condition in Reference.enqueue()
ysr
parents: 5506
diff changeset
    75
     *     next = this
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    76
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    77
     *     Enqueued: queue = ReferenceQueue.ENQUEUED; next = Following instance
90ce3da70b43 Initial load
duke
parents:
diff changeset
    78
     *     in queue, or this if at end of list.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    79
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    80
     *     Inactive: queue = ReferenceQueue.NULL; next = this.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    81
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    82
     * With this scheme the collector need only examine the next field in order
90ce3da70b43 Initial load
duke
parents:
diff changeset
    83
     * to determine whether a Reference instance requires special treatment: If
90ce3da70b43 Initial load
duke
parents:
diff changeset
    84
     * the next field is null then the instance is active; if it is non-null,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    85
     * then the collector should treat the instance normally.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    86
     *
10895
7434064aba55 4243978: (ref) Race condition in Reference.enqueue()
ysr
parents: 5506
diff changeset
    87
     * To ensure that a concurrent collector can discover active Reference
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    88
     * objects without interfering with application threads that may apply
90ce3da70b43 Initial load
duke
parents:
diff changeset
    89
     * the enqueue() method to those objects, collectors should link
10895
7434064aba55 4243978: (ref) Race condition in Reference.enqueue()
ysr
parents: 5506
diff changeset
    90
     * discovered objects through the discovered field. The discovered
7434064aba55 4243978: (ref) Race condition in Reference.enqueue()
ysr
parents: 5506
diff changeset
    91
     * field is also used for linking Reference objects in the pending list.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    92
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    93
90ce3da70b43 Initial load
duke
parents:
diff changeset
    94
    private T referent;         /* Treated specially by GC */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    95
18815
5da35ed47cfa 8014890: (ref) Reference queues may return more entries than expected
mchung
parents: 17716
diff changeset
    96
    volatile ReferenceQueue<? super T> queue;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    97
10895
7434064aba55 4243978: (ref) Race condition in Reference.enqueue()
ysr
parents: 5506
diff changeset
    98
    /* When active:   NULL
7434064aba55 4243978: (ref) Race condition in Reference.enqueue()
ysr
parents: 5506
diff changeset
    99
     *     pending:   this
7434064aba55 4243978: (ref) Race condition in Reference.enqueue()
ysr
parents: 5506
diff changeset
   100
     *    Enqueued:   next reference in queue (or this if last)
7434064aba55 4243978: (ref) Race condition in Reference.enqueue()
ysr
parents: 5506
diff changeset
   101
     *    Inactive:   this
7434064aba55 4243978: (ref) Race condition in Reference.enqueue()
ysr
parents: 5506
diff changeset
   102
     */
19053
69648476a89e 8021429: Fix lint warnings in java.lang.ref
darcy
parents: 18815
diff changeset
   103
    @SuppressWarnings("rawtypes")
32100
8a0db19f4e84 8059036: Implement Diagnostic Commands for heap and finalizerinfo
dsamersoff
parents: 31671
diff changeset
   104
    volatile Reference next;
10895
7434064aba55 4243978: (ref) Race condition in Reference.enqueue()
ysr
parents: 5506
diff changeset
   105
7434064aba55 4243978: (ref) Race condition in Reference.enqueue()
ysr
parents: 5506
diff changeset
   106
    /* When active:   next element in a discovered reference list maintained by GC (or this if last)
7434064aba55 4243978: (ref) Race condition in Reference.enqueue()
ysr
parents: 5506
diff changeset
   107
     *     pending:   next element in the pending list (or null if last)
7434064aba55 4243978: (ref) Race condition in Reference.enqueue()
ysr
parents: 5506
diff changeset
   108
     *   otherwise:   NULL
7434064aba55 4243978: (ref) Race condition in Reference.enqueue()
ysr
parents: 5506
diff changeset
   109
     */
32649
2ee9017c7597 8136583: Core libraries should use blessed modifier order
martin
parents: 32100
diff changeset
   110
    private transient Reference<T> discovered;  /* used by VM */
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   111
90ce3da70b43 Initial load
duke
parents:
diff changeset
   112
90ce3da70b43 Initial load
duke
parents:
diff changeset
   113
    /* Object used to synchronize with the garbage collector.  The collector
90ce3da70b43 Initial load
duke
parents:
diff changeset
   114
     * must acquire this lock at the beginning of each collection cycle.  It is
90ce3da70b43 Initial load
duke
parents:
diff changeset
   115
     * therefore critical that any code holding this lock complete as quickly
90ce3da70b43 Initial load
duke
parents:
diff changeset
   116
     * as possible, allocate no new objects, and avoid calling user code.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   117
     */
32649
2ee9017c7597 8136583: Core libraries should use blessed modifier order
martin
parents: 32100
diff changeset
   118
    private static class Lock { }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   119
    private static Lock lock = new Lock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   120
90ce3da70b43 Initial load
duke
parents:
diff changeset
   121
90ce3da70b43 Initial load
duke
parents:
diff changeset
   122
    /* List of References waiting to be enqueued.  The collector adds
90ce3da70b43 Initial load
duke
parents:
diff changeset
   123
     * References to this list, while the Reference-handler thread removes
10895
7434064aba55 4243978: (ref) Race condition in Reference.enqueue()
ysr
parents: 5506
diff changeset
   124
     * them.  This list is protected by the above lock object. The
7434064aba55 4243978: (ref) Race condition in Reference.enqueue()
ysr
parents: 5506
diff changeset
   125
     * list uses the discovered field to link its elements.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   126
     */
19053
69648476a89e 8021429: Fix lint warnings in java.lang.ref
darcy
parents: 18815
diff changeset
   127
    private static Reference<Object> pending = null;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   128
90ce3da70b43 Initial load
duke
parents:
diff changeset
   129
    /* High-priority thread to enqueue pending References
90ce3da70b43 Initial load
duke
parents:
diff changeset
   130
     */
34716
7477a052aecc 8056152: API to create Threads that do not inherit inheritable thread-local initial values
chegar
parents: 32834
diff changeset
   131
    private static class ReferenceHandler extends Thread {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   132
22615
e929c13f8d11 8022321: java/lang/ref/OOMEInReferenceHandler.java fails intermittently
plevart
parents: 19053
diff changeset
   133
        private static void ensureClassInitialized(Class<?> clazz) {
e929c13f8d11 8022321: java/lang/ref/OOMEInReferenceHandler.java fails intermittently
plevart
parents: 19053
diff changeset
   134
            try {
e929c13f8d11 8022321: java/lang/ref/OOMEInReferenceHandler.java fails intermittently
plevart
parents: 19053
diff changeset
   135
                Class.forName(clazz.getName(), true, clazz.getClassLoader());
e929c13f8d11 8022321: java/lang/ref/OOMEInReferenceHandler.java fails intermittently
plevart
parents: 19053
diff changeset
   136
            } catch (ClassNotFoundException e) {
e929c13f8d11 8022321: java/lang/ref/OOMEInReferenceHandler.java fails intermittently
plevart
parents: 19053
diff changeset
   137
                throw (Error) new NoClassDefFoundError(e.getMessage()).initCause(e);
e929c13f8d11 8022321: java/lang/ref/OOMEInReferenceHandler.java fails intermittently
plevart
parents: 19053
diff changeset
   138
            }
e929c13f8d11 8022321: java/lang/ref/OOMEInReferenceHandler.java fails intermittently
plevart
parents: 19053
diff changeset
   139
        }
e929c13f8d11 8022321: java/lang/ref/OOMEInReferenceHandler.java fails intermittently
plevart
parents: 19053
diff changeset
   140
e929c13f8d11 8022321: java/lang/ref/OOMEInReferenceHandler.java fails intermittently
plevart
parents: 19053
diff changeset
   141
        static {
e929c13f8d11 8022321: java/lang/ref/OOMEInReferenceHandler.java fails intermittently
plevart
parents: 19053
diff changeset
   142
            // pre-load and initialize InterruptedException and Cleaner classes
e929c13f8d11 8022321: java/lang/ref/OOMEInReferenceHandler.java fails intermittently
plevart
parents: 19053
diff changeset
   143
            // so that we don't get into trouble later in the run loop if there's
e929c13f8d11 8022321: java/lang/ref/OOMEInReferenceHandler.java fails intermittently
plevart
parents: 19053
diff changeset
   144
            // memory shortage while loading/initializing them lazily.
e929c13f8d11 8022321: java/lang/ref/OOMEInReferenceHandler.java fails intermittently
plevart
parents: 19053
diff changeset
   145
            ensureClassInitialized(InterruptedException.class);
e929c13f8d11 8022321: java/lang/ref/OOMEInReferenceHandler.java fails intermittently
plevart
parents: 19053
diff changeset
   146
            ensureClassInitialized(Cleaner.class);
e929c13f8d11 8022321: java/lang/ref/OOMEInReferenceHandler.java fails intermittently
plevart
parents: 19053
diff changeset
   147
        }
e929c13f8d11 8022321: java/lang/ref/OOMEInReferenceHandler.java fails intermittently
plevart
parents: 19053
diff changeset
   148
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   149
        ReferenceHandler(ThreadGroup g, String name) {
34716
7477a052aecc 8056152: API to create Threads that do not inherit inheritable thread-local initial values
chegar
parents: 32834
diff changeset
   150
            super(g, null, name, 0, false);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   151
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   152
90ce3da70b43 Initial load
duke
parents:
diff changeset
   153
        public void run() {
23009
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   154
            while (true) {
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   155
                tryHandlePending(true);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   156
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   157
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   158
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   159
23009
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   160
    /**
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   161
     * Try handle pending {@link Reference} if there is one.<p>
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   162
     * Return {@code true} as a hint that there might be another
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   163
     * {@link Reference} pending or {@code false} when there are no more pending
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   164
     * {@link Reference}s at the moment and the program can do some other
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   165
     * useful work instead of looping.
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   166
     *
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   167
     * @param waitForNotify if {@code true} and there was no pending
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   168
     *                      {@link Reference}, wait until notified from VM
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   169
     *                      or interrupted; if {@code false}, return immediately
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   170
     *                      when there is no pending {@link Reference}.
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   171
     * @return {@code true} if there was a {@link Reference} pending and it
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   172
     *         was processed, or we waited for notification and either got it
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   173
     *         or thread was interrupted before being notified;
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   174
     *         {@code false} otherwise.
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   175
     */
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   176
    static boolean tryHandlePending(boolean waitForNotify) {
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   177
        Reference<Object> r;
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   178
        Cleaner c;
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   179
        try {
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   180
            synchronized (lock) {
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   181
                if (pending != null) {
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   182
                    r = pending;
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   183
                    // 'instanceof' might throw OutOfMemoryError sometimes
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   184
                    // so do this before un-linking 'r' from the 'pending' chain...
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   185
                    c = r instanceof Cleaner ? (Cleaner) r : null;
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   186
                    // unlink 'r' from 'pending' chain
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   187
                    pending = r.discovered;
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   188
                    r.discovered = null;
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   189
                } else {
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   190
                    // The waiting on the lock may cause an OutOfMemoryError
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   191
                    // because it may try to allocate exception objects.
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   192
                    if (waitForNotify) {
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   193
                        lock.wait();
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   194
                    }
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   195
                    // retry if waited
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   196
                    return waitForNotify;
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   197
                }
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   198
            }
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   199
        } catch (OutOfMemoryError x) {
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   200
            // Give other threads CPU time so they hopefully drop some live references
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   201
            // and GC reclaims some space.
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   202
            // Also prevent CPU intensive spinning in case 'r instanceof Cleaner' above
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   203
            // persistently throws OOME for some time...
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   204
            Thread.yield();
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   205
            // retry
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   206
            return true;
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   207
        } catch (InterruptedException x) {
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   208
            // retry
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   209
            return true;
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   210
        }
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   211
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   212
        // Fast path for cleaners
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   213
        if (c != null) {
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   214
            c.clean();
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   215
            return true;
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   216
        }
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   217
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   218
        ReferenceQueue<? super Object> q = r.queue;
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   219
        if (q != ReferenceQueue.NULL) q.enqueue(r);
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   220
        return true;
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   221
    }
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   222
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   223
    static {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   224
        ThreadGroup tg = Thread.currentThread().getThreadGroup();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   225
        for (ThreadGroup tgn = tg;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   226
             tgn != null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   227
             tg = tgn, tgn = tg.getParent());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   228
        Thread handler = new ReferenceHandler(tg, "Reference Handler");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   229
        /* If there were a special system-only priority greater than
90ce3da70b43 Initial load
duke
parents:
diff changeset
   230
         * MAX_PRIORITY, it would be used here
90ce3da70b43 Initial load
duke
parents:
diff changeset
   231
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   232
        handler.setPriority(Thread.MAX_PRIORITY);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   233
        handler.setDaemon(true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   234
        handler.start();
23009
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   235
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   236
        // provide access in SharedSecrets
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   237
        SharedSecrets.setJavaLangRefAccess(new JavaLangRefAccess() {
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   238
            @Override
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   239
            public boolean tryHandlePendingReference() {
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   240
                return tryHandlePending(false);
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   241
            }
e2c92ddeb57f 6857566: (bf) DirectByteBuffer garbage creation can outpace reclamation
plevart
parents: 22615
diff changeset
   242
        });
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   243
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   244
90ce3da70b43 Initial load
duke
parents:
diff changeset
   245
    /* -- Referent accessor and setters -- */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   246
90ce3da70b43 Initial load
duke
parents:
diff changeset
   247
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   248
     * Returns this reference object's referent.  If this reference object has
90ce3da70b43 Initial load
duke
parents:
diff changeset
   249
     * been cleared, either by the program or by the garbage collector, then
90ce3da70b43 Initial load
duke
parents:
diff changeset
   250
     * this method returns <code>null</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   251
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   252
     * @return   The object to which this reference refers, or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   253
     *           <code>null</code> if this reference object has been cleared
90ce3da70b43 Initial load
duke
parents:
diff changeset
   254
     */
31671
362e0c0acece 8076112: Add @HotSpotIntrinsicCandidate annotation to indicate methods for which Java Runtime has intrinsics
zmajo
parents: 29919
diff changeset
   255
    @HotSpotIntrinsicCandidate
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   256
    public T get() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   257
        return this.referent;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   258
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   259
90ce3da70b43 Initial load
duke
parents:
diff changeset
   260
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   261
     * Clears this reference object.  Invoking this method will not cause this
90ce3da70b43 Initial load
duke
parents:
diff changeset
   262
     * object to be enqueued.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   263
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   264
     * <p> This method is invoked only by Java code; when the garbage collector
90ce3da70b43 Initial load
duke
parents:
diff changeset
   265
     * clears references it does so directly, without invoking this method.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   266
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   267
    public void clear() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   268
        this.referent = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   269
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   270
90ce3da70b43 Initial load
duke
parents:
diff changeset
   271
90ce3da70b43 Initial load
duke
parents:
diff changeset
   272
    /* -- Queue operations -- */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   273
90ce3da70b43 Initial load
duke
parents:
diff changeset
   274
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   275
     * Tells whether or not this reference object has been enqueued, either by
90ce3da70b43 Initial load
duke
parents:
diff changeset
   276
     * the program or by the garbage collector.  If this reference object was
90ce3da70b43 Initial load
duke
parents:
diff changeset
   277
     * not registered with a queue when it was created, then this method will
90ce3da70b43 Initial load
duke
parents:
diff changeset
   278
     * always return <code>false</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   279
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   280
     * @return   <code>true</code> if and only if this reference object has
90ce3da70b43 Initial load
duke
parents:
diff changeset
   281
     *           been enqueued
90ce3da70b43 Initial load
duke
parents:
diff changeset
   282
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   283
    public boolean isEnqueued() {
18815
5da35ed47cfa 8014890: (ref) Reference queues may return more entries than expected
mchung
parents: 17716
diff changeset
   284
        return (this.queue == ReferenceQueue.ENQUEUED);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   285
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   286
90ce3da70b43 Initial load
duke
parents:
diff changeset
   287
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   288
     * Adds this reference object to the queue with which it is registered,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   289
     * if any.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   290
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   291
     * <p> This method is invoked only by Java code; when the garbage collector
90ce3da70b43 Initial load
duke
parents:
diff changeset
   292
     * enqueues references it does so directly, without invoking this method.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   293
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   294
     * @return   <code>true</code> if this reference object was successfully
90ce3da70b43 Initial load
duke
parents:
diff changeset
   295
     *           enqueued; <code>false</code> if it was already enqueued or if
90ce3da70b43 Initial load
duke
parents:
diff changeset
   296
     *           it was not registered with a queue when it was created
90ce3da70b43 Initial load
duke
parents:
diff changeset
   297
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   298
    public boolean enqueue() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   299
        return this.queue.enqueue(this);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   300
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   301
90ce3da70b43 Initial load
duke
parents:
diff changeset
   302
90ce3da70b43 Initial load
duke
parents:
diff changeset
   303
    /* -- Constructors -- */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   304
90ce3da70b43 Initial load
duke
parents:
diff changeset
   305
    Reference(T referent) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   306
        this(referent, null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   307
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   308
90ce3da70b43 Initial load
duke
parents:
diff changeset
   309
    Reference(T referent, ReferenceQueue<? super T> queue) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   310
        this.referent = referent;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   311
        this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   312
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   313
35254
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   314
    /**
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   315
     * Ensures that the object referenced by the given reference remains
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   316
     * <a href="package-summary.html#reachability"><em>strongly reachable</em></a>,
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   317
     * regardless of any prior actions of the program that might otherwise cause
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   318
     * the object to become unreachable; thus, the referenced object is not
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   319
     * reclaimable by garbage collection at least until after the invocation of
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   320
     * this method.  Invocation of this method does not itself initiate garbage
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   321
     * collection or finalization.
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   322
     *
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   323
     * <p> This method establishes an ordering for
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   324
     * <a href="package-summary.html#reachability"><em>strong reachability</em></a>
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   325
     * with respect to garbage collection.  It controls relations that are
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   326
     * otherwise only implicit in a program -- the reachability conditions
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   327
     * triggering garbage collection.  This method is designed for use in
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   328
     * uncommon situations of premature finalization where using
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   329
     * {@code synchronized} blocks or methods, or using other synchronization
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   330
     * facilities are not possible or do not provide the desired control.  This
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   331
     * method is applicable only when reclamation may have visible effects,
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   332
     * which is possible for objects with finalizers (See
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   333
     * <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-12.html#jls-12.6">
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   334
     * Section 12.6 17 of <cite>The Java&trade; Language Specification</cite></a>)
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   335
     * that are implemented in ways that rely on ordering control for correctness.
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   336
     *
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   337
     * @apiNote
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   338
     * Finalization may occur whenever the virtual machine detects that no
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   339
     * reference to an object will ever be stored in the heap: The garbage
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   340
     * collector may reclaim an object even if the fields of that object are
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   341
     * still in use, so long as the object has otherwise become unreachable.
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   342
     * This may have surprising and undesirable effects in cases such as the
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   343
     * following example in which the bookkeeping associated with a class is
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   344
     * managed through array indices.  Here, method {@code action} uses a
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   345
     * {@code reachabilityFence} to ensure that the {@code Resource} object is
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   346
     * not reclaimed before bookkeeping on an associated
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   347
     * {@code ExternalResource} has been performed; in particular here, to
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   348
     * ensure that the array slot holding the {@code ExternalResource} is not
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   349
     * nulled out in method {@link Object#finalize}, which may otherwise run
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   350
     * concurrently.
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   351
     *
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   352
     * <pre> {@code
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   353
     * class Resource {
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   354
     *   private static ExternalResource[] externalResourceArray = ...
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   355
     *
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   356
     *   int myIndex;
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   357
     *   Resource(...) {
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   358
     *     myIndex = ...
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   359
     *     externalResourceArray[myIndex] = ...;
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   360
     *     ...
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   361
     *   }
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   362
     *   protected void finalize() {
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   363
     *     externalResourceArray[myIndex] = null;
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   364
     *     ...
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   365
     *   }
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   366
     *   public void action() {
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   367
     *     try {
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   368
     *       // ...
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   369
     *       int i = myIndex;
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   370
     *       Resource.update(externalResourceArray[i]);
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   371
     *     } finally {
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   372
     *       Reference.reachabilityFence(this);
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   373
     *     }
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   374
     *   }
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   375
     *   private static void update(ExternalResource ext) {
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   376
     *     ext.status = ...;
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   377
     *   }
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   378
     * }}</pre>
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   379
     *
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   380
     * Here, the invocation of {@code reachabilityFence} is nonintuitively
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   381
     * placed <em>after</em> the call to {@code update}, to ensure that the
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   382
     * array slot is not nulled out by {@link Object#finalize} before the
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   383
     * update, even if the call to {@code action} was the last use of this
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   384
     * object.  This might be the case if, for example a usage in a user program
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   385
     * had the form {@code new Resource().action();} which retains no other
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   386
     * reference to this {@code Resource}.  While probably overkill here,
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   387
     * {@code reachabilityFence} is placed in a {@code finally} block to ensure
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   388
     * that it is invoked across all paths in the method.  In a method with more
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   389
     * complex control paths, you might need further precautions to ensure that
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   390
     * {@code reachabilityFence} is encountered along all of them.
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   391
     *
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   392
     * <p> It is sometimes possible to better encapsulate use of
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   393
     * {@code reachabilityFence}.  Continuing the above example, if it were
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   394
     * acceptable for the call to method {@code update} to proceed even if the
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   395
     * finalizer had already executed (nulling out slot), then you could
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   396
     * localize use of {@code reachabilityFence}:
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   397
     *
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   398
     * <pre> {@code
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   399
     * public void action2() {
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   400
     *   // ...
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   401
     *   Resource.update(getExternalResource());
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   402
     * }
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   403
     * private ExternalResource getExternalResource() {
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   404
     *   ExternalResource ext = externalResourceArray[myIndex];
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   405
     *   Reference.reachabilityFence(this);
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   406
     *   return ext;
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   407
     * }}</pre>
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   408
     *
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   409
     * <p> Method {@code reachabilityFence} is not required in constructions
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   410
     * that themselves ensure reachability.  For example, because objects that
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   411
     * are locked cannot, in general, be reclaimed, it would suffice if all
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   412
     * accesses of the object, in all methods of class {@code Resource}
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   413
     * (including {@code finalize}) were enclosed in {@code synchronized (this)}
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   414
     * blocks.  (Further, such blocks must not include infinite loops, or
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   415
     * themselves be unreachable, which fall into the corner case exceptions to
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   416
     * the "in general" disclaimer.)  However, method {@code reachabilityFence}
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   417
     * remains a better option in cases where this approach is not as efficient,
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   418
     * desirable, or possible; for example because it would encounter deadlock.
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   419
     *
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   420
     * @param ref the reference. If {@code null}, this method has no effect.
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   421
     * @since 9
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   422
     */
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   423
    @DontInline
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   424
    public static void reachabilityFence(Object ref) {
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   425
        // Does nothing, because this method is annotated with @DontInline
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   426
        // HotSpot needs to retain the ref and not GC it before a call to this
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   427
        // method
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   428
    }
ba6a26f39b86 8133348: Reference.reachabilityFence
psandoz
parents: 32834
diff changeset
   429
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   430
}