public final class CrawlingParameterUtil {
    private static final ThreadLocal<UrlQueue<?>> URL_QUEUE_THREAD_LOCAL = new ThreadLocal<>();

    private static final ThreadLocal<CrawlerContext> ROBOT_CONTEXT_THREAD_LOCAL = new ThreadLocal<>();

    private static final ThreadLocal<UrlQueueService<UrlQueue<?>>> URL_QUEUE_SERVICE_THREAD_LOCAL = new ThreadLocal<>();

    return requireNonNull(DEST_TL.get());
  }

  /**
   * A thread-local destination buffer to keep us from creating new buffers. The starting size is
   * 1024 characters. If we grow past this we don't put it back in the threadlocal, we just keep
   * going and grow as needed.
   */
  private static final ThreadLocal<char[]> DEST_TL =
      new ThreadLocal<char[]>() {

        inputStream.defaultReadObject();
        hideCause = threadLocal();
    }

    private void writeObject(java.io.ObjectOutputStream out) throws IOException {
        // Ensure fields are initialized before serialization
        String ignored = getMessage();
        out.defaultWriteObject();
    }

    private ThreadLocal<Boolean> threadLocal() {
        return new HideStacktrace();
    }

    @Override

    private val threadLocalExplicitAnalysisRestriction: ThreadLocal<KaExplicitAnalysisRestriction?> =
        ThreadLocal.withInitial { null }

    private val threadLocalAllowOnEdt: ThreadLocal<Boolean> =
        ThreadLocal.withInitial { false }

    private val threadLocalAllowInWriteAction: ThreadLocal<Boolean> =
        ThreadLocal.withInitial { false }

    return requireNonNull(DEST_TL.get());
  }

  /**
   * A thread-local destination buffer to keep us from creating new buffers. The starting size is
   * 1024 characters. If we grow past this we don't put it back in the threadlocal, we just keep
   * going and grow as needed.
   */
  private static final ThreadLocal<char[]> DEST_TL =
      new ThreadLocal<char[]>() {

import javax.annotation.Nullable;
import java.util.ArrayDeque;
import java.util.Deque;

public class RuleContext {

    private static final ThreadLocal<Deque<ModelRuleDescriptor>> STACK = ThreadLocal.withInitial(ArrayDeque::new);

    @Nullable
    public static ModelRuleDescriptor get() {
        return STACK.get().peek();
    }

 * limitations under the License.
 */

package org.gradle.cache.internal.cacheops;

public class CacheAccessOperationsStack {
    @SuppressWarnings("ThreadLocalUsage")
    private final ThreadLocal<CacheOperationStack> stackForThread = new ThreadLocal<>();

    public void pushCacheAction() {
        CacheOperationStack stack = getOrCreateStack();
        stack.pushCacheAction();
    }

    public void popCacheAction() {

@NonNullApi
public class PerThreadInstrumentedGroovyCallsTracker implements InstrumentedGroovyCallsTracker {
    private final ThreadLocal<InstrumentedGroovyCallsTracker> perThreadImplementation;

    public PerThreadInstrumentedGroovyCallsTracker(Supplier<InstrumentedGroovyCallsTracker> implementationSupplier) {
        perThreadImplementation = ThreadLocal.withInitial(implementationSupplier);
    }

    @Override

    private final ThreadLocal<Queue<Event>> queue =
        new ThreadLocal<Queue<Event>>() {
          @Override
          protected Queue<Event> initialValue() {
            return Queues.newArrayDeque();
          }
        };

    /** Per-thread dispatch state, used to avoid reentrant event dispatching. */
    private final ThreadLocal<Boolean> dispatching =
        new ThreadLocal<Boolean>() {

    private final ThreadLocal<Queue<Event>> queue =
        new ThreadLocal<Queue<Event>>() {
          @Override
          protected Queue<Event> initialValue() {
            return Queues.newArrayDeque();
          }
        };

    /** Per-thread dispatch state, used to avoid reentrant event dispatching. */
    private final ThreadLocal<Boolean> dispatching =
        new ThreadLocal<Boolean>() {