**DI**: LastaFlute container with `@Resource` and XML config

### Core Principles

**Thread Safety**:
- `AtomicLong` for counters (`CrawlerContext.accessCount`)
- `volatile` for status flags
- Synchronized blocks for critical sections
- Thread-local storage via `CrawlingParameterUtil`

**Resource Management**:
- `AutoCloseable` throughout

    /**
     * The timestamp of the last access to this handle
     */
    private volatile long lastAccessTime;

    /**
     * The associated lease key if this handle has an SMB2 lease
     */
    private final Smb2LeaseKey leaseKey;

    /**
     * Flag indicating whether this handle is currently being reconnected
     */
    private volatile boolean reconnecting;

    // Not serialized - will be null after deserialization

    private final ExecutorService executor = newSingleThreadExecutor();

    FakeService() {
      tearDownStack.addTearDown(this);
    }

    volatile int startupCalled = 0;
    volatile int shutdownCalled = 0;
    volatile int runCalled = 0;

    @Override
    protected void startUp() throws Exception {
      assertEquals(0, startupCalled);
      assertEquals(0, runCalled);

internal class RealEventSource(
  private val request: Request,
  private val listener: EventSourceListener,
) : EventSource,
  ServerSentEventReader.Callback,
  Callback {
  private var call: Call? = null

  @Volatile private var canceled = false

  fun connect(callFactory: Call.Factory) {
    call =
      callFactory.newCall(request).apply {
        enqueue(this@RealEventSource)
      }
  }

  override fun onResponse(

  private val http2Connection: Http2Connection,
) : ExchangeCodec {
  @Volatile private var stream: Http2Stream? = null

  private val protocol: Protocol =
    if (Protocol.H2_PRIOR_KNOWLEDGE in client.protocols) {
      Protocol.H2_PRIOR_KNOWLEDGE
    } else {
      Protocol.HTTP_2
    }

  @Volatile
  private var canceled = false

  override val isResponseComplete: Boolean

    public volatile boolean done = false;

    @Override
    public void run() {
      try {
        delay(SHORT_DELAY_MS);
        done = true;
      } catch (InterruptedException ok) {
      }
    }
  }

  public static class TrackedSmallRunnable implements Runnable {
    public volatile boolean done = false;

    @Override

    private static final Logger logger = LogManager.getLogger(LabelTypeHelper.class);

    /** A list of label type items. */
    protected volatile List<LabelTypeItem> labelTypeItemList;

    /** A list of label type patterns. */
    protected volatile List<LabelTypePattern> labelTypePatternList;

    /**
     * Default constructor.
     */
    public LabelTypeHelper() {
        super();
    }

        defaultLegacySupport.setSession(m2);
        latch.countDown();
        thread.join();
        assertNull(myRunnable.getSession());
    }

    class MyRunnable implements Runnable {

        private volatile MavenSession session;

        @Override
        public void run() {
            try {
                latch.await();
            } catch (InterruptedException ignore) {

/** A holder for a {@link Logger} that is initialized only when requested. */
@GwtCompatible
final class LazyLogger {
  private final Object lock = new Object();

  private final String loggerName;
  private volatile @Nullable Logger logger;

  LazyLogger(Class<?> ownerOfLogger) {
    this.loggerName = ownerOfLogger.getName();
  }

  Logger get() {
    /*

  private var expectMoreExchanges = true

  // These properties are accessed by canceling threads. Any thread can cancel a call, and once it's
  // canceled it's canceled forever.

  @Volatile private var canceled = false

  @Volatile private var exchange: Exchange? = null
  internal val plansToCancel = CopyOnWriteArrayList<RoutePlanner.Plan>()

  private val tags = AtomicReference(originalRequest.tags)