2 * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.yangtools.util;
10 import com.google.common.annotations.Beta;
11 import com.google.common.base.Preconditions;
12 import java.util.AbstractMap.SimpleEntry;
13 import java.util.ArrayDeque;
14 import java.util.Deque;
15 import java.util.Map.Entry;
16 import javax.annotation.Nullable;
17 import javax.annotation.concurrent.ThreadSafe;
18 import org.slf4j.Logger;
19 import org.slf4j.LoggerFactory;
22 * Thread-local hack to make recursive extensions work without too much hassle. The idea is that prior to instantiating
23 * an extension, the definition object checks whether it is already present on the stack, recorded object is returned.
26 * If it is not, it will push itself to the stack as unresolved and invoke the constructor. The constructor's lowermost
27 * class calls to this class and if the topmost entry is not resolved, it will leak itself.
30 * Upon return from the constructor, the topmost entry is removed and if the queue is empty, the thread-local variable
34 * WARNING: BE CAREFUL WHEN USING THIS CLASS. IT LEAKS OBJECTS WHICH ARE NOT COMPLETELY INITIALIZED.
37 * WARNING: THIS CLASS EAVES THREAD-LOCAL RESIDUE. MAKE SURE IT IS OKAY OR CALL {@link #cleanup()} IN APPROPRIATE
41 * THIS CLASS IS EXTREMELY DANGEROUS (okay, not as much as sun.misc.unsafe). YOU HAVE BEEN WARNED. IF SOMETHING BREAKS
42 * IT IS PROBABLY YOUR FAULT AND YOU ARE ON YOUR OWN.
44 * @author Robert Varga
48 public final class RecursiveObjectLeaker {
49 // Logging note. Only keys passed can be logged, as objects beng resolved may not be properly constructed.
50 private static final Logger LOG = LoggerFactory.getLogger(RecursiveObjectLeaker.class);
52 // Initial value is set to null on purpose, so we do not allocate anything (aside the map)
53 private static final ThreadLocal<Deque<Entry<?, Object>>> STACK = new ThreadLocal<>();
55 private RecursiveObjectLeaker() {
56 throw new UnsupportedOperationException();
59 // Key is checked for identity
60 public static void beforeConstructor(final Object key) {
61 Deque<Entry<?, Object>> stack = STACK.get();
63 // Biased: this class is expected to be rarely and shallowly used
64 stack = new ArrayDeque<>(1);
68 LOG.debug("Resolving key {}", key);
69 stack.push(new SimpleEntry<>(key, null));
72 // Can potentially store a 'null' mapping. Make sure cleanup() is called
73 public static void inConstructor(final Object obj) {
74 final Deque<Entry<?, Object>> stack = STACK.get();
76 final Entry<?, Object> top = stack.peek();
78 if (top.getValue() == null) {
79 LOG.debug("Resolved key {}", top.getKey());
83 LOG.info("Cleaned stale empty stack", new Exception());
87 LOG.trace("No thread stack");
91 // Make sure to call this from a finally block
92 public static void afterConstructor(final Object key) {
93 final Deque<Entry<?, Object>> stack = STACK.get();
94 Preconditions.checkState(stack != null, "No stack allocated when completing %s", key);
96 final Entry<?, Object> top = stack.pop();
97 if (stack.isEmpty()) {
98 LOG.trace("Removed empty thread stack");
102 Preconditions.checkState(key == top.getKey(), "Expected key %s, have %s", top.getKey(), key);
103 Preconditions.checkState(top.getValue() != null, "");
106 // BEWARE: this method returns incpmpletely-initialized objects (that is the purpose of this class).
108 // BE VERY CAREFUL WHAT OBJECT STATE YOU TOUCH
109 public static @Nullable <T> T lookup(final Object key, final Class<T> requiredClass) {
110 final Deque<Entry<?, Object>> stack = STACK.get();
112 for (Entry<?, Object> e : stack) {
113 // Keys are treated as identities
114 if (key == e.getKey()) {
115 Preconditions.checkState(e.getValue() != null, "Object for %s is not resolved", key);
116 LOG.debug("Looked up key {}", e.getKey());
117 return requiredClass.cast(e.getValue());
125 // Be sure to call this in from a finally block when bulk processing is done, so that this class can be unloaded
126 public static void cleanup() {
128 LOG.debug("Removed thread state");