<li>

    <api type="export" group="systemproperty" name="netbeans.CallbackReferences.delayShutdownOfCallbackThread" category="devel">

        controls the shutdown of background daemon thread that process the

        reference callbacks. When there are no more references to process,

        the thread dies after the specified time in milliseconds.

        If the value is <code>"infinity"</code> or <code>"never"</code>,

        the background thread runs indefinitely and references processing

        is a bit more efficient. Set this property if you know that there will

        always be some references waiting for processing in the system.

        The default value is <code>0</code> - to shut down the background

        thread immediately when there are no more references waiting for processing.

        This property works since version 8.34

    </api>

    </li>

import java.lang.ref.Reference;

import java.util.concurrent.atomic.AtomicBoolean;

import org.openide.util.lookup.implspi.CallbackReferencesSupport;

        private static final AtomicBoolean registered = new AtomicBoolean(false);

        private static final class CallbackHandlerImpl implements CallbackReferencesSupport.CallbackHandler {

            @Override

            public void handleCallback(Reference reference) {

                ((ReferenceToResult) reference).handleCallback(reference);

            }

        }

import org.openide.util.lookup.implspi.CallbackReferencesSupport.CallbackHandler;

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2015 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2015 Sun Microsystems, Inc.

 */

package org.openide.util.lookup.implspi;

import java.lang.ref.Reference;

import java.lang.ref.ReferenceQueue;

import java.util.HashMap;

import java.util.Map;

import java.util.logging.Logger;

/**

 * Support class for building callback references. Callback references are able

 * to execute a dedicated callback when the object the reference refers to, becomes unreachable.

 * <p>

 * Do not use this class, unless you know well what you're doing. Use rather

 * <code>org.openide.util.CallbackReferences</code> instead.

 * <p>

 * <b>Usage:</b>

 * <ol>

 * <li>Get the default implementation of this support from {@link CallbackReferencesSupport#getDefault()}</li>

 * <li>Create the desired reference with {@link #getReferenceQueue()}.

 *     It's important that there is one reference instance per one

 *     CallbackReferencesSupport instance.</li>

 * <li>Register the reference for finalization by calling

 *     {@link #registerReferenceFinalizer(java.lang.ref.Reference)} method.</li>

 * <li>Register the reference class with the callback handler via

 *     {@link #registerCallbackHandler(java.lang.Class, org.openide.util.lookup.implspi.CallbackReferencesSupport.CallbackHandler)}</li>

 * <li>It's important that there is exactly one call to {@link #getReferenceQueue()}

 *     and {@link #registerReferenceFinalizer(java.lang.ref.Reference)} per

 *     a reference instance.</li>

 * </ol>

 * 

 * @author Martin Entlicher

 * @since 8.34

 * @see org.openide.util.CallbackReferences

 */

public abstract class CallbackReferencesSupport {

    static final Logger LOGGER = Logger.getLogger(CallbackReferencesSupportFinishable.class.getName());

    static final long CALLBACK_THREAD_SHUTDOWN_DELAY = getCallbackThreadShutdownDelay();

    private static final boolean INDEFINITE_CALLBACK_THREAD = CALLBACK_THREAD_SHUTDOWN_DELAY == Long.MAX_VALUE;

    private static final CallbackReferencesSupport DEFAULT = createDefault();

    static final Map<Class<? extends Reference>, CallbackHandler> callbackHandlers = new HashMap<Class<? extends Reference>, CallbackHandler>();

    CallbackReferencesSupport() {}

    private static long getCallbackThreadShutdownDelay() {

        String prop = System.getProperty("netbeans.CallbackReferences.delayShutdownOfCallbackThread");  // NOI18N

        if (prop == null) {

            return 0;   // Shutdown immediately

        }

        prop = prop.toLowerCase();

        if ("never".equals(prop) || "infinity".equals(prop) || "inf".equals(prop)) {    // NOI18N

            return Long.MAX_VALUE;

        }

        try {

            return Long.decode(prop);

        } catch (NumberFormatException e) {

            return 0;

        }

    }

    private static CallbackReferencesSupport createDefault() {

        if (INDEFINITE_CALLBACK_THREAD) {

            return new CallbackReferencesSupportIndefinite();

        } else {

            return new CallbackReferencesSupportFinishable();

        }

    }

    /**

     * Get the default implementation of {@link CallbackReferencesSupport}.

     * @return The default {@link CallbackReferencesSupport}.

     */

    public static CallbackReferencesSupport getDefault() {

        return DEFAULT;

    }

    /**

     * Register a callback handler associated with the reference class type.

     * @param refClass The class type of the reference.

     * @param callbackHandler The handler of the reference callback.

     */

    public static void registerCallbackHandler(Class<? extends Reference> refClass, CallbackHandler callbackHandler) {

        synchronized (callbackHandlers) {

            callbackHandlers.put(refClass, callbackHandler);

        }

    }

    /**

     * Get the reference queue, solely for the purpose of reference creation.

     * @return The reference queue.

     */

    public abstract ReferenceQueue getReferenceQueue();

    /**

     * Be sure to call this method for every instance of this class,

     * to assure that the finalization of the associated reference is correctly

     * handled.

     * @param ref The associated reference

     */

    public abstract void registerReferenceFinalizer(Reference ref);

    static final CallbackHandler getCallbackHandler(Reference ref) {

        Class refClass = ref.getClass();

        CallbackHandler callbackHandler = null;

        synchronized (callbackHandlers) {

            for (Map.Entry<Class<? extends Reference>, CallbackHandler> entry : callbackHandlers.entrySet()) {

                if (entry.getKey().isAssignableFrom(refClass)) {

                    callbackHandler = entry.getValue();

                    break;

                }

            }

        }

        return callbackHandler;

    }

    final void cleanup(Reference ref) {

        CallbackHandler callbackHandler = getCallbackHandler(ref);

        if (callbackHandler != null) {

            callbackHandler.handleCallback(ref);

        } else {

            LOGGER.warning("No callback handler for reference "+ref+" of class "+ref.getClass()); // NOI18N

        }

    }

    /**

     * Handler of a reference callback for the given {@link Reference}.

     * @see #registerCallbackHandler(java.lang.Class, org.openide.util.lookup.implspi.CallbackReferencesSupport.CallbackHandler)

     */

    public static interface CallbackHandler {

        /**

         * Perform the callback for the given reference.

         * @param ref The reference

         */

        void handleCallback(Reference ref);

    }

}

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2015 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2015 Sun Microsystems, Inc.

 */

package org.openide.util.lookup.implspi;

import java.lang.ref.Reference;

import java.lang.ref.ReferenceQueue;

import java.lang.ref.WeakReference;

import java.util.Collections;

import java.util.HashMap;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.Map;

import java.util.logging.Level;

/**

 * Callback reference support with a finishable background thread.

 * 

 * @author martin

 */

final class CallbackReferencesSupportFinishable extends CallbackReferencesSupport {

    private long activeRefsCount = 0l;

    private final Object LOCK = new Object();

    private ReferenceQueue callbackRefQueue;  // Current callback reference queue

    private final Map<Object, FinalizingReference> finalizingReferences = Collections.synchronizedMap(new HashMap<Object, FinalizingReference>());

    private Daemon running;

    CallbackReferencesSupportFinishable() {

    }

    /**

     * Get the reference queue, solely for the purpose of reference creation.

     * @return The reference queue.

     */

    @Override

    public ReferenceQueue getReferenceQueue() {

        ReferenceQueue rq;

        synchronized (LOCK) {

            activeRefsCount++;  // The queue is retrieved for a single reference

            rq = callbackRefQueue;

            if (rq == null) {

                rq = new ReferenceQueue();

                callbackRefQueue = rq;

                pingDaemon();

            }

        }

        return rq;

    }

    /**

     * Be sure to call this method for every instance of this class,

     * to assure that the finalization of the associated reference is correctly

     * handled.

     * @param ref The associated reference

     */

    @Override

    public void registerReferenceFinalizer(Reference ref) {

        FinalizingReference fr = new FinalizingReference(ref, getReferenceQueue());

        if (LOGGER.isLoggable(Level.FINE)) {

            synchronized (LOCK) {

                LOGGER.log(Level.FINE, "new FinalizingReference: activeRefsCount = {0}", activeRefsCount);

            }

        }

        finalizingReferences.put(fr, fr);

    }

    private void died() {

        boolean isLoggable = LOGGER.isLoggable(Level.FINE);

        synchronized (LOCK) {

            if ((activeRefsCount -= 2) == 0) {

                callbackRefQueue = null;

                if (running != null) {

                    running.doFinish();

                }

            }

            if (isLoggable) {

                LOGGER.log(Level.FINE, "DIED: activeRefsCount = {0}", activeRefsCount);

            }

        }

    }

    private static final class FinalizingReference extends WeakReference<Reference> {

        final int hashCode;

        public FinalizingReference(Reference referent, ReferenceQueue rq) {

            super(referent, rq);

            this.hashCode = System.identityHashCode(referent);

        }

        @Override

        public int hashCode() {

            return hashCode;

        }

        @Override

        public boolean equals(Object obj) {

            if (obj instanceof FinalizingReference) {

                FinalizingReference other = (FinalizingReference) obj;

                if (hashCode != other.hashCode) {

                    return false;

                }

                return get() == other.get();

            } else if (obj instanceof ReferenceKey) {

                Reference referent = get();

                ReferenceKey rk = (ReferenceKey) obj;

                return rk.compareToNullRef && referent == null || referent == rk.ref;

            } else if (obj instanceof FinalizingKey) {

                return this == ((FinalizingKey) obj).fr;

            }

            return false;

        }

    }

    private static class ReferenceKey {

        private final int hashCode;

        final Reference ref;

        final boolean compareToNullRef;

        public ReferenceKey(Reference ref, boolean compareToNullRef) {

            this.ref = ref;

            this.hashCode = System.identityHashCode(ref);

            this.compareToNullRef = compareToNullRef;

        }

        @Override

        public int hashCode() {

            return hashCode;

        }

        @Override

        public boolean equals(Object obj) {

            if (obj instanceof FinalizingReference) {

                FinalizingReference fr = (FinalizingReference) obj;

                if (fr.hashCode != hashCode) {

                    return false;

                }

                Reference frRef = fr.get();

                return compareToNullRef && frRef == null || frRef == ref;

            }

            return false;

        }

    }

    private static final class FinalizingKey {

        final FinalizingReference fr;

        private final int hashCode;

        public FinalizingKey(FinalizingReference fr) {

            this.fr = fr;

            this.hashCode = fr.hashCode;

        }

        @Override

        public int hashCode() {

            return hashCode;

        }

        @Override

        public boolean equals(Object obj) {

            return obj == fr;

        }

    }

    static boolean isDaemonRunning() {

        CallbackReferencesSupportFinishable support = (CallbackReferencesSupportFinishable) CallbackReferencesSupport.getDefault();

        synchronized (support.LOCK) {

            return support.running != null;

        }

    }

    private void pingDaemon() {

        synchronized (LOCK) {

            if (running == null) {

                Daemon t = new Daemon();

                t.setPriority(Thread.MIN_PRIORITY);

                t.setDaemon(true);

                t.start();

                LOGGER.fine("starting thread");

                running = t;

            } else {

                LOCK.notifyAll();

            }

        }

    }

    private final class Daemon extends Thread {

        public Daemon() {

            super("Cleanable Reference Queue Daemon");      // NOI18N

        }

        private void doFinish() {

            interrupt();

        }

        @Override

        public void run() {

            final LinkedList<FinalizingReference> postponedFinalizingReferences = new LinkedList<FinalizingReference>();

            Reference<?> nextRef = null;

            while (true) {

                try {

                    ReferenceQueue rq;

                    synchronized (LOCK) {

                        rq = callbackRefQueue;

                        if (rq == null) {

                            assert finalizingReferences.isEmpty() : finalizingReferences.toString();

                            assert postponedFinalizingReferences.isEmpty() : postponedFinalizingReferences.toString();

                            if (CALLBACK_THREAD_SHUTDOWN_DELAY > 0) {

                                LOCK.wait(CALLBACK_THREAD_SHUTDOWN_DELAY);

                                rq = callbackRefQueue;

                            }

                            if (rq == null) {

                                LOGGER.fine("Daemon DIES.");

                                running = null;

                                return ;

                            }

                        }

                    }

                    boolean fromQueue = false;

                    Reference<?> ref = nextRef;

                    nextRef = null;

                    if (ref == null) {

                        ref = rq.poll();

                    }

                    if (!postponedFinalizingReferences.isEmpty() && ref == null) {

                        ref = postponedFinalizingReferences.removeFirst();

                    } else {

                        if (ref == null) {

                            ref = rq.remove();

                        }

                        fromQueue = true;

                    }

                    LOGGER.log(Level.FINE, "Got {0}", new Object[] { ref });

                    boolean finalizing = ref instanceof FinalizingReference;

                    if (finalizing) {

                        FinalizingKey finalizingKey = new FinalizingKey((FinalizingReference) ref);

                        if (fromQueue && finalizingReferences.containsKey(finalizingKey)) {

                            nextRef = rq.poll();

                            if (nextRef != null) {

                                // There are other items in the queue, process them before finalizing references:

                                postponedFinalizingReferences.add((FinalizingReference) ref);

                                continue;

                            }

                        }

                        FinalizingReference removed = finalizingReferences.remove(finalizingKey);

                        if (removed != null) {

                            // No callback, the reference was collected

                            died();

                        } else {

                            // The reference was collected, but the callback was processed already.

                        }

                    } else {

                        FinalizingReference removed = finalizingReferences.remove(new ReferenceKey(ref, false));

                        if (removed == null) {

                            removed = finalizingReferences.remove(new ReferenceKey(ref, true));

                        }

                        if (removed != null) {

                            // Remove from postponedFinalizingReferences list if it happens to be there

                            // Need to manually iterate through, because of the necessary identity comparisons:

                            Iterator<FinalizingReference> frIt = postponedFinalizingReferences.iterator();

                            while (frIt.hasNext()) {

                                if (frIt.next() == removed) {

                                    frIt.remove();

                                    break;

                                }

                            }

                            // do the cleanup

                            try {

                                cleanup(ref);

                            } catch (ThreadDeath td) {

                                throw td;

                            } catch (Throwable t) {

                                // Should not happen.

                                // If it happens, it is a bug in client code, notify!

                                LOGGER.log(Level.WARNING, "Cannot process " + ref, t);

                            }

                            removed.clear();

                            died();

                        } else {

                            LOGGER.log(Level.WARNING, "Finalizing reference missing.",

                                       new IllegalStateException("No finalizing reference for "+ref));

                        }

                    }

                } catch (InterruptedException ex) {

                    // Can happen during VM shutdown, or by finish call.

                    continue;

                }

            }

        }

    }

}

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2015 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2015 Sun Microsystems, Inc.

 */

package org.openide.util.lookup.implspi;

import java.lang.ref.Reference;

import java.lang.ref.ReferenceQueue;

/**

 * Callback reference support with an indefinite background thread.

 * 

 * @author martin

 */

class CallbackReferencesSupportIndefinite extends CallbackReferencesSupport {

    CallbackReferencesSupportIndefinite() {

    }

    @Override

    public ReferenceQueue getReferenceQueue() {

        return ActiveQueue.queue();

    }

    @Override

    public void registerReferenceFinalizer(Reference ref) {

        // No need for finalizers

    }

}

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2015 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2015 Sun Microsystems, Inc.

 */

package org.openide.util.lookup.implspi;

import java.lang.ref.Reference;

import static junit.framework.TestCase.assertFalse;

import static junit.framework.TestCase.assertTrue;

import org.netbeans.junit.NbTestCase;

/**

 *

 * @author martin

 */

public class CallbackReferencesSupportDelayedTest extends NbTestCase {

    public CallbackReferencesSupportDelayedTest(String testName) {

        super(testName);

    }

    public void testDaemonShutdownDelay() throws InterruptedException {

        int delay = 5000;

        System.setProperty("netbeans.CallbackReferences.delayShutdownOfCallbackThread", Integer.toString(delay));

        int repeats = 3;

        while (repeats-- > 0) {

            new CallbackReferencesSupportTest.TestWeak(new Object(), new CallbackReferencesSupportTest.SupportCallback() {

                @Override public void referenceCleared(Reference ref) {}

            });

            long startTime = System.currentTimeMillis();

            CallbackReferencesSupportFinishable crsf = (CallbackReferencesSupportFinishable) CallbackReferencesSupport.getDefault();

            boolean active = crsf.isDaemonRunning();

            assertTrue(active);

            long endTime = startTime + delay - 200;

            long cTime = System.currentTimeMillis();

            int i;

            for (i = 0; crsf.isDaemonRunning() && cTime < endTime; i++) {

                System.gc();

                Thread.sleep(50);

                cTime = System.currentTimeMillis();

            }

            active = crsf.isDaemonRunning();

            assertTrue("Daemon should not die sooner than "+delay+", died after "+(cTime - startTime)+"ms", active);

            for (i = 0; i < 10 && crsf.isDaemonRunning(); i++) {

                System.gc();

                Thread.sleep(50);

            }

            active = crsf.isDaemonRunning();

            assertFalse("Daemon should die after "+delay, active);

        }

        System.clearProperty("netbeans.CallbackReferences.delayShutdownOfCallbackThread");

    }

}

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2015 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2015 Sun Microsystems, Inc.

 */

package org.openide.util.lookup.implspi;

import java.lang.ref.Reference;

import java.lang.ref.ReferenceQueue;

import org.netbeans.junit.NbTestCase;

/**

 *

 * @author martin

 */

public class CallbackReferencesSupportIndefiniteTest extends NbTestCase {

    public CallbackReferencesSupportIndefiniteTest(String testName) {

        super(testName);

    }

    public void testDaemonNeverShutdown() throws InterruptedException {

        System.setProperty("netbeans.CallbackReferences.delayShutdownOfCallbackThread", "infinity");

        new CallbackReferencesSupportTest.TestWeak(new Object(), new CallbackReferencesSupportTest.SupportCallback() {

            @Override public void referenceCleared(Reference ref) {}

        });

        assertTrue(CallbackReferencesSupport.getDefault() instanceof CallbackReferencesSupportIndefinite);

        ReferenceQueue rq = CallbackReferencesSupport.getDefault().getReferenceQueue();

        assertEquals(ActiveQueue.queue(), rq);

        System.clearProperty("netbeans.CallbackReferences.delayShutdownOfCallbackThread");

    }

}

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2015 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2015 Sun Microsystems, Inc.

 */

package org.openide.util.lookup.implspi;

import java.lang.ref.Reference;

import java.lang.ref.ReferenceQueue;

import java.lang.ref.WeakReference;

import java.util.LinkedHashMap;

import java.util.Map;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.logging.Handler;

import java.util.logging.Level;

import java.util.logging.LogRecord;

import java.util.logging.Logger;

import org.netbeans.junit.Log;

import org.netbeans.junit.NbTestCase;

import org.openide.util.lookup.implspi.CallbackReferencesSupport.CallbackHandler;

/**

 *

 * @author martin

 */

public class CallbackReferencesSupportTest extends NbTestCase {

    private LoggerWarningsHandler logHandler;

    public CallbackReferencesSupportTest(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        Logger log = Logger.getLogger(CallbackReferencesSupport.class.getName());

        Log.enable(log.getName(), Level.FINEST);

        logHandler = new LoggerWarningsHandler();

        log.addHandler(logHandler);

    }

    @Override

    protected void tearDown() throws Exception {

        assertFalse(logHandler.toString(), logHandler.hasMessages());

        Logger log = Logger.getLogger(CallbackReferencesSupport.class.getName());

        log.removeHandler(logHandler);

        logHandler = null;

    }

    public void testCleanupCallback() throws Exception {

        final boolean[] cleared = new boolean[] { false };

        final boolean[] finalized = new boolean[] { false };

        SupportCallback callback = new SupportCallback() {

            @Override

            public void referenceCleared(Reference ref) {

                synchronized (cleared) {

                    cleared[0] = true;

                    cleared.notifyAll();

                }

            }

        };

        // Hold the reference and free the referent:

        System.err.println("Hold the reference and free the referent");

        Object obj = new Object();

        TestWeakWithFinalize twf = new TestWeakWithFinalize(obj, callback, finalized);

        CallbackReferencesSupportFinishable crsf = (CallbackReferencesSupportFinishable) CallbackReferencesSupport.getDefault();

        boolean active = crsf.isDaemonRunning();

        assertTrue("The daemon started", active);

        WeakReference objRef = new WeakReference(obj);

        obj = null;

        assertGC("Object should be GC'ed", objRef);

        synchronized (cleared) {

            while (!cleared[0]) {

                cleared.wait(100);

                System.gc();

            }

        }

        assertTrue(cleared[0]);

        assertFalse(finalized[0]);

        active = crsf.isDaemonRunning();

        assertFalse("The daemon should finish", active);

        WeakReference twRef = new WeakReference(twf);

        twf = null;

        assertGC("TestWeak reference should be GC'ed", twRef);

        synchronized (finalized) {

            while (!finalized[0]) {

                finalized.wait(100);

                System.gc();

            }

        }

        assertTrue(finalized[0]);

        // Reset:

        cleared[0] = false;

        finalized[0] = false;

        // Free the reference and hold the referent

        System.err.println("Free the reference and hold the referent");

        obj = new Object();

        twf = new TestWeakWithFinalize(obj, callback, finalized);

        active = crsf.isDaemonRunning();

        assertTrue("The daemon started", active);

        twRef = new WeakReference(twf);

        twf = null;

        assertGC("TestWeak reference should be GC'ed", twRef);

        synchronized (finalized) {

            while (!finalized[0]) {

                finalized.wait(100);

                System.gc();

            }

        }

        assertTrue(finalized[0]);

        assertFalse(cleared[0]); // Should never clear

        objRef = new WeakReference(obj);

        obj = null;

        assertGC("Object should be GC'ed", objRef);

        assertFalse(cleared[0]); // Should never clear

        while (crsf.isDaemonRunning()) {

            System.gc();

            Thread.sleep(100);

        }

        active = crsf.isDaemonRunning();

        assertFalse("The daemon should finish", active);

        // Reset:

        cleared[0] = false;

        finalized[0] = false;

        // Free both the reference and the referent

        System.err.println("Free both the reference and the referent");

        obj = new Object();

        TestWeak tw = new TestWeak(obj, callback);

        active = crsf.isDaemonRunning();

        assertTrue("The daemon started", active);

        objRef = new WeakReference(obj);

        obj = null;

        twRef = new WeakReference(tw);

        tw = null;

        assertGC("Object should be GC'ed", objRef);

        assertGC("TestWeak reference should be GC'ed", twRef);

        while (crsf.isDaemonRunning()) {

            System.gc();

            Thread.sleep(100);

        }

        // Free several referents and hold the references

        System.err.println("Free several referents and hold the references");

        int n = 500000;

        Object[] objs = new Object[n];

        TestWeak[] tws = new TestWeak[n];

        final boolean[] calledBack = new boolean[n];

        SupportCallback cb = new SupportCallback() {

            @Override public void referenceCleared(Reference ref) {

                calledBack[((TestWeak) ref).id] = true;

            }

        };

        for (int i = 0; i < n; i++) {

            objs[i] = new Object();

            tws[i] = new TestWeak(objs[i], cb);

            tws[i].id = i;

        }

        active = crsf.isDaemonRunning();

        assertTrue("The daemon started", active);

        WeakReference[] objRefs = new WeakReference[n];

        WeakReference[] twRefs = new WeakReference[n];

        for (int i = 0; i < n; i++) {

            objRefs[i] = new WeakReference(objs[i]);

            twRefs[i] = new WeakReference(tws[i]);

        }

        objs = null;

        for (int i = 0; i < n; i++) {

            assertGC("Object "+i+" should be GC'ed", objRefs[i]);

            assertEquals(tws[i], twRefs[i].get());

        }

        while (crsf.isDaemonRunning()) {

            System.gc();

            Thread.sleep(100);

        }

        String ncb = null;

        for (int i = 0; i < n; i++) {

            if (!calledBack[i]) {

                if (ncb == null) {

                    ncb = Integer.toString(i);

                } else {

                    ncb += ", "+i;

                }

            }

        }

        assertNull("Not called back: "+ncb, ncb);

        tws = null;

        for (int i = 0; i < n; i++) {

            assertGC("TestWeak reference "+i+" should be GC'ed", twRefs[i]);

        }

        // Free several references and the referents

        System.err.println("Free several references and the referents");

        objs = new Object[n];

        tws = new TestWeak[n];

        for (int i = 0; i < n; i++) {

            objs[i] = new Object();

            tws[i] = new TestWeak(objs[i], cb);

            tws[i].id = i;

        }

        active = crsf.isDaemonRunning();

        assertTrue("The daemon started", active);

        objRefs = new WeakReference[n];

        twRefs = new WeakReference[n];

        for (int i = 0; i < n; i++) {

            objRefs[i] = new WeakReference(objs[i]);

            twRefs[i] = new WeakReference(tws[i]);

        }

        objs = null;

        tws = null;

        for (int i = 0; i < n; i++) {

            assertGC("Object "+i+" should be GC'ed", objRefs[i]);

            assertGC("TestWeak reference "+i+" should be GC'ed", twRefs[i]);

        }

        while (crsf.isDaemonRunning()) {

            System.gc();

            Thread.sleep(100);

        }

    }

    public void testNullRefs() throws Exception {

        final boolean[] cleared = new boolean[] { false };

        final boolean[] finalized = new boolean[] { false };

        /*CallbackReferencesSupport support = CallbackReferencesSupport.create(new SupportCallback() {

            @Override

            public void referenceCleared(Reference ref) {

                cleared[0] = true;

            }

        });*/

        CallbackReferencesSupport support = CallbackReferencesSupport.getDefault();

        new WeakReferenceOnNull(support, finalized);

        CallbackReferencesSupportFinishable crsf = (CallbackReferencesSupportFinishable) CallbackReferencesSupport.getDefault();

        boolean active = crsf.isDaemonRunning();

        // is probably active, unless the WeakReferenceOnNull was already finalized.

        synchronized (finalized) {

            while (!finalized[0]) {

                finalized.wait(100);

                System.gc();

            }

        }

        assertTrue("The weak ref was not finalized?!?", finalized[0]);

        //WeakReference supportRef = new WeakReference(support);

        //support = null;

        //assertGC("The support should be GC'ed", supportRef);

        // Since the ref was null, the clearing callback was not called:

        assertFalse("Unexpectedly cleared!", cleared[0]);

        while (crsf.isDaemonRunning()) {

            System.gc();

            Thread.sleep(100);

        }

        active = crsf.isDaemonRunning();

        assertFalse("The daemon shoud die!", active);

        /*

        boolean isNPE = false;

        try {

            new TestWeak(new Object(), (SupportCallback) null, null);

        } catch (NullPointerException npex) {

            isNPE = true;

        }

        assertTrue(isNPE);

        */

        active = crsf.isDaemonRunning();

        assertFalse("NPE should not start the daemon", active);

    }

    private static class WeakReferenceOnNull extends WeakReference {

        private final CallbackReferencesSupport support;

        private final boolean[] finalized;

        public WeakReferenceOnNull(CallbackReferencesSupport support, boolean[] finalized) {

            super(null, support.getReferenceQueue());

            this.support = support;

            support.registerReferenceFinalizer(this);

            this.finalized = finalized;

        }

        @Override

        protected void finalize() throws Throwable {

            synchronized (finalized) {

                finalized[0] = true;

                finalized.notifyAll();

            }

            super.finalize();

            //support.notifyFinalized();

        }

    }

    static class TestWeak<T> extends WeakReference<T> {

        private static final AtomicBoolean REGISTERED = new AtomicBoolean(false);

        final SupportCallback cleanup;

        int id;

        public TestWeak(T referent, SupportCallback cleanup) {

            this(referent, cleanup, CallbackReferencesSupport.getDefault());

        }

        private TestWeak(T referent, SupportCallback cleanup, CallbackReferencesSupport support) {

            super(referent, support.getReferenceQueue());

            this.cleanup = cleanup;

            support.registerReferenceFinalizer(this);

            if (!REGISTERED.getAndSet(true)) {

                CallbackReferencesSupport.registerCallbackHandler(TestWeak.class, new TestCallbackHandler());

            }

        }

        private static final class TestCallbackHandler implements CallbackHandler {

            @Override

            public void handleCallback(Reference ref) {

                ((TestWeak) ref).cleanup.referenceCleared(ref);

            }

        }

    }

    static class TestWeakWithFinalize<T> extends WeakReference<T> {

        private static final AtomicBoolean REGISTERED = new AtomicBoolean(false);

        final SupportCallback cleanup;

        private final boolean[] finalized;

        int id;

        public TestWeakWithFinalize(T referent, SupportCallback cleanup, boolean[] finalized) {

            this(referent, cleanup, CallbackReferencesSupport.getDefault(), finalized);

        }

        private TestWeakWithFinalize(T referent, SupportCallback cleanup, CallbackReferencesSupport support, boolean[] finalized) {

            super(referent, support.getReferenceQueue());

            this.cleanup = cleanup;

            support.registerReferenceFinalizer(this);

            this.finalized = finalized;

            if (!REGISTERED.getAndSet(true)) {

                CallbackReferencesSupport.registerCallbackHandler(TestWeakWithFinalize.class, new TestCallbackHandler());

            }

        }

        @Override

        protected final void finalize() throws Throwable {

            //System.err.println("TestWeak finzalizing...");

            //support.notifyFinalized();

            super.finalize();

            if (finalized != null) {

                synchronized (finalized) {

                    finalized[0] = true;

                    finalized.notifyAll();

                }

            }

        }

        private static final class TestCallbackHandler implements CallbackHandler {

            @Override

            public void handleCallback(Reference ref) {

                ((TestWeakWithFinalize) ref).cleanup.referenceCleared(ref);

            }

        }

    }

    static interface SupportCallback {

        void referenceCleared(Reference ref);

    }

    private static class LoggerWarningsHandler extends Handler {

        private final Map<String, Level> messages = new LinkedHashMap<String, Level>();

        public LoggerWarningsHandler() {

        }

        @Override

        public void publish(LogRecord record) {

            Level f = record.getLevel();

            if (f.intValue() >= Level.CONFIG.intValue()) {

                messages.put(record.getMessage(), f);

            }

        }

        @Override

        public void flush() {

        }

        @Override

        public void close() throws SecurityException {

        }

        public boolean hasMessages() {

            return !messages.isEmpty();

        }

        @Override

        public String toString() {

            return "LoggerWarningsHandler: "+messages.toString();

        }

    }

}

    <change id="callback-references">

        <api name="util_base"/>

        <summary>CallbackReferences class provides references that are able to

            call a defined callback, after the referent object becomes unreachable.</summary>

        <version major="9" minor="8"/>

        <date year="2015" month="12" day="15"/>

        <author login="mentlicher"/>

        <compatibility addition="yes" binary="compatible" source="compatible"/>

        <description>

            <p>

                <code>CallbackReferences</code> class provides a set of reference

                implementations that are able to process the given callback runnable,

                after their referent object becomes unreachable. The callback

                processing is performed on a dedicated daemon thread,

                which is shut down when there are no more callbacks to process.

            </p>

        </description>

        <class package="org.openide.util" name="CallbackReferences"/>

        <issue number="257013"/>

    </change>

     * @Deprecated This API requires an indefinitely running background thread.

     *             Use {@link CallbackReferences} instead.

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2015 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2015 Sun Microsystems, Inc.

 */

package org.openide.util;

import java.lang.ref.PhantomReference;

import java.lang.ref.Reference;

import java.lang.ref.SoftReference;

import java.lang.ref.WeakReference;

import java.util.concurrent.atomic.AtomicBoolean;

import org.openide.util.lookup.implspi.CallbackReferencesSupport;

import org.openide.util.lookup.implspi.CallbackReferencesSupport.CallbackHandler;

/**

 * This class provides references, that are able to call a defined callback,

 * after the referent object becomes unreachable. It is useful when there is

 * a need to run a callback code after the referent is collected.

 * <p>

 * Usually, in order to implement such logic, one needs to either create

 * a dedicated thread that blocks on the queue and is <code>Object.notify</code>-ed,

 * which is the right approach but consumes valuable system resources (threads),

 * or one can periodically check the content of the queue by

 * <code>RequestProcessor.Task.schedule</code> which is completely wrong,

 * because it wakes up the system every (say) 15 seconds.

 * <p>

 * In order to provide an efficient support for this problem, these references

 * has been provided. They share one background thread to process the callbacks,

 * which dies when there are no more callbacks to process.<br>

 * Be sure not to block in such callbacks for a long time as this prevents other

 * waiting references from processing.

 * 

 * @author Martin Entlicher

 * @since 9.8

 */

public final class CallbackReferences {

    private CallbackReferences() {}

    private static <T> T referentCheck(T referent) {

        if (referent == null) {

            throw new NullPointerException("The referent must not be null.");   // NOI18N

        }

        return referent;

    }

    private static Callback checkCallback(Callback callback) {

        if (callback == null) {

            throw new NullPointerException("The callback must not be null.");   // NOI18N

        }

        return callback;

    }

    /**

     * An implementation of {@link PhantomReference} with a callback functionality.

     * After the referent becomes unreachable, the provided Runnable callback is executed.

     */

    public static class Phantom<T> extends PhantomReference<T> {

        private static final AtomicBoolean REGISTERED = new AtomicBoolean(false);

        private final Callback callback;

        /**

         * Create a new phantom reference with a callback. Both referent and the

         * callback should not be <code>null</code>.

         * @param referent the object the new phantom reference will refer to

         * @param callback the callback executed after the referent becomes unreachable.

         */

        public Phantom(T referent, Callback callback) {

            this(referentCheck(referent), checkCallback(callback), CallbackReferencesSupport.getDefault());

        }

        private Phantom(T referent, Callback callback, CallbackReferencesSupport support) {

            super(referent, support.getReferenceQueue());

            this.callback = callback;

            support.registerReferenceFinalizer(this);

            if (!REGISTERED.getAndSet(true)) {

                CallbackReferencesSupport.registerCallbackHandler(Phantom.class, new PhantomCallbackHandler());

            }

        }

        private static final class PhantomCallbackHandler implements CallbackHandler {

            public void handleCallback(Reference ref) {

                ((Phantom) ref).callback.referenceCleared(ref);

            }

        }

    }

    /**

     * An implementation of {@link SoftReference} with a callback functionality.

     * After the referent becomes unreachable, the provided Runnable callback is executed.

     */

    public static class Soft<T> extends SoftReference<T> {

        private static final AtomicBoolean REGISTERED = new AtomicBoolean(false);

        private final Callback callback;

        /**

         * Create a new soft reference with a callback. Both referent and the

         * callback should not be <code>null</code>.

         * @param referent the object the new soft reference will refer to

         * @param callback the callback executed after the referent becomes unreachable.

         */

        public Soft(T referent, Callback callback) {

            this(referentCheck(referent), checkCallback(callback), CallbackReferencesSupport.getDefault());

        }

        private Soft(T referent, Callback callback, CallbackReferencesSupport support) {

            super(referent, support.getReferenceQueue());

            this.callback = callback;

            support.registerReferenceFinalizer(this);

            if (!REGISTERED.getAndSet(true)) {

                CallbackReferencesSupport.registerCallbackHandler(Soft.class, new SoftCallbackHandler());

            }

        }

        private static final class SoftCallbackHandler implements CallbackHandler {

            @Override

            public void handleCallback(Reference ref) {

                ((Soft) ref).callback.referenceCleared(ref);

            }

        }

    }

    /**

     * An implementation of {@link WeakReference} with a callback functionality.

     * After the referent becomes unreachable, the provided Runnable callback is executed.

     */

    public static class Weak<T> extends WeakReference<T> {

        private static final AtomicBoolean REGISTERED = new AtomicBoolean(false);

        private final Callback callback;

        /**

         * Create a new weak reference with a callback. Both referent and the

         * callback should not be <code>null</code>.

         * @param referent the object the new weak reference will refer to

         * @param callback the callback executed after the referent becomes unreachable.

         */

        public Weak(T referent, Callback callback) {

            this(referentCheck(referent), checkCallback(callback), CallbackReferencesSupport.getDefault());

        }

        private Weak(T referent, Callback callback, CallbackReferencesSupport support) {

            super(referent, support.getReferenceQueue());

            this.callback = callback;

            support.registerReferenceFinalizer(this);

            if (!REGISTERED.getAndSet(true)) {

                CallbackReferencesSupport.registerCallbackHandler(Weak.class, new WeakCallbackHandler());

            }

        }

        private static final class WeakCallbackHandler implements CallbackHandler {

            @Override

            public void handleCallback(Reference ref) {

                ((Weak) ref).callback.referenceCleared(ref);

            }

        }

    }

    /**

     * The callback, which is notified about cleared references.

     */

    public static interface Callback {

        /**

         * Called when a reference is cleared.

         * @param reference The cleared reference.

         */

        void referenceCleared(Reference reference);

    }

    /**

     * An abstract {@link PhantomReference}, which acts itself as a callback

     * by implementing {@link Runable}.

     * After the referent becomes unreachable, it's <code>run()</code> method

     * is executed.

     */

    public static abstract class PhantomCallback<T> extends PhantomReference<T> implements Runnable {

        private static final AtomicBoolean REGISTERED = new AtomicBoolean(false);

        /**

         * Create a new phantom callback reference.

         * @param referent the object the new phantom reference will refer to

         */

        public PhantomCallback(T referent) {

            super(referentCheck(referent), CallbackReferencesSupport.getDefault().getReferenceQueue());

            CallbackReferencesSupport.getDefault().registerReferenceFinalizer(this);

            if (!REGISTERED.getAndSet(true)) {

                CallbackReferencesSupport.registerCallbackHandler(PhantomCallback.class, new RunnableCallback());

            }

        }

    }

    /**

     * An abstract {@link SoftReference}, which acts itself as a callback

     * by implementing {@link Runable}.

     * After the referent becomes unreachable, it's <code>run()</code> method

     * is executed.

     */

    public static abstract class SoftCallback<T> extends SoftReference<T> implements Runnable {

        private static final AtomicBoolean REGISTERED = new AtomicBoolean(false);

        /**

         * Create a new soft callback reference.

         * @param referent the object the new phantom reference will refer to

         */

        public SoftCallback(T referent) {

            super(referentCheck(referent), CallbackReferencesSupport.getDefault().getReferenceQueue());

            CallbackReferencesSupport.getDefault().registerReferenceFinalizer(this);

            if (!REGISTERED.getAndSet(true)) {

                CallbackReferencesSupport.registerCallbackHandler(SoftCallback.class, new RunnableCallback());

            }

        }

    }

    /**

     * An abstract {@link WeakReference}, which acts itself as a callback

     * by implementing {@link Runable}.

     * After the referent becomes unreachable, it's <code>run()</code> method

     * is executed.

     */

    public static abstract class WeakCallback<T> extends WeakReference<T> implements Runnable {

        private static final AtomicBoolean REGISTERED = new AtomicBoolean(false);

        /**

         * Create a new weak callback reference.

         * @param referent the object the new phantom reference will refer to

         */

        public WeakCallback(T referent) {

            super(referentCheck(referent), CallbackReferencesSupport.getDefault().getReferenceQueue());

            CallbackReferencesSupport.getDefault().registerReferenceFinalizer(this);

            if (!REGISTERED.getAndSet(true)) {

                CallbackReferencesSupport.registerCallbackHandler(WeakCallback.class, new RunnableCallback());

            }

        }

    }

    private static final class RunnableCallback implements CallbackHandler {

        @Override

        public void handleCallback(Reference ref) {

            ((Runnable) ref).run();

        }

    }

}

    <a href="../CallbackReferences.html"><code>CallbackReferences</code></a> which contain

    implementation of references, that are able to call a defined callback,

    after the referent object becomes unreachable.

    </li>

    <li>

    <a href="../CallbackReferences.html"><code>CallbackReferences</code></a> which contain

    implementation of references, that are able to call a defined callback,

    after the referent object becomes unreachable.

    </li>

    <li>

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2015 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2015 Sun Microsystems, Inc.

 */

package org.openide.util;

import java.lang.ref.Reference;

import java.lang.reflect.Method;

import static junit.framework.TestCase.assertTrue;

import org.netbeans.junit.NbTestCase;

import static org.netbeans.junit.NbTestCase.assertGC;

import org.openide.util.lookup.implspi.CallbackReferencesSupport;