throw this.e;
        }
    }

    synchronized void write(final byte[] buffer, final int len, final SmbFileOutputStream d) {
        this.b = buffer;
        this.n = len;
        this.out = d;
        this.ready = false;
        notify();
    }

    @Override
    public void run() {
        synchronized (this) {
            try {
                for (;;) {

                log.debug("Usage dropped to zero, release connection " + this.transport);
            }
            // Ensure atomic cleanup of all resources
            synchronized (this) {
                // Double-check usage count within synchronized block
                if (this.usageCount.get() != 0) {
                    return; // Another thread acquired the session
                }

        void testReceived() throws InterruptedException {
            CountDownLatch latch = new CountDownLatch(1);

            Thread waiter = new Thread(() -> {
                synchronized (response) {
                    try {
                        if (!response.isReceived()) {
                            response.wait(1000);
                        }
                        latch.countDown();

        super("ECL0041", asArray(targetClass.getName(), cause), cause);
        this.targetClass = targetClass;
    }

    @Override
    public synchronized InstantiationRuntimeException initCause(final Throwable cause) {
        return (InstantiationRuntimeException) super.initCause(cause);
    }

    /**
     * Returns the target class.
     *

            }
        }
        obj = getCachedAddress(name);
        if (obj == null) {
            synchronized (LOOKUP_TABLE) {
                LOOKUP_TABLE.put(name, name);
            }
        }

        return obj;
    }

    private static void updateLookupTable(final Name name) {
        synchronized (LOOKUP_TABLE) {
            LOOKUP_TABLE.remove(name);
            LOOKUP_TABLE.notifyAll();
        }

        }
        return beanDesc;
    }

    /**
     * Performs initialization.
     */
    public static void initialize() {
        synchronized (BeanDescFactory.class) {
            if (!initialized) {
                DisposableUtil.add(BeanDescFactory::clear);
                initialized = true;
            }
        }
    }

    /**

    int readDataWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        if (pipe.pipeIn != null) {
            final TransactNamedPipeInputStream in = (TransactNamedPipeInputStream) pipe.pipeIn;
            synchronized (in.lock) {
                in.receive(buffer, bufferIndex, len);
                in.lock.notify();
            }
        }
        return len;
    }

    @Override
    public String toString() {

 * It extends {@link LinkedHashMap} without synchronization. If multiple threads access
 * an instance concurrently, and at least one thread modifies the map structurally,
 * it must be synchronized externally.
 * </p>
 * <p>
 * For thread-safe usage, wrap with {@link java.util.Collections#synchronizedMap(Map)}:
 * </p>
 * <pre>
 * Map&lt;K, V&gt; syncMap = Collections.synchronizedMap(new LruHashMap&lt;&gt;(100));

            // Test implementation
        }
    }

    // ========== Thread Safety Tests for getDataStoreNames() ==========

    /**
     * Test concurrent getDataStoreNames calls to verify synchronized method works correctly.
     * Multiple threads call getDataStoreNames() simultaneously.
     */
    @Test
    public void test_getDataStoreNames_concurrentAccess() throws Exception {

  private volatile @Nullable Object mutexDoNotUseDirectly;

  private Object mutex() {
    Object mutex = mutexDoNotUseDirectly;
    if (mutex == null) {
      synchronized (this) {
        mutex = mutexDoNotUseDirectly;
        if (mutex == null) {
          mutexDoNotUseDirectly = mutex = new Object();
        }
      }
    }
    return mutex;
  }