// we are in the transport thread, ie. on idle disconnecting
                // this is synchronous operation
                // This does not handle compound requests
                synchronized (this.inLock) {
                    final Long peekKey = peekKey();
                    if (peekKey == firstKey) {
                        doRecv(response);
                        response.received();

     * @return
     */
    private synchronized SmbTreeImpl getTreeInternal() {
        final SmbTreeImpl t = this.tree;
        if (t != null) {
            return t;
        }
        if (this.delegate != null) {
            return this.delegate.getTreeInternal();
        }
        return null;
    }

    /**
     * @param t
     */
    private synchronized void switchTree(final SmbTreeImpl t) {

            }
        }
        obj = getCachedAddress(name);
        if (obj == null) {
            synchronized (this.inFlightLookups) {
                this.inFlightLookups.add(name);
            }
        }

        return obj;
    }

    private void updateLookupTable(final Name name) {
        synchronized (this.inFlightLookups) {
            this.inFlightLookups.remove(name);

        }

        if (track && this.traceResource) {
            synchronized (this.acquires) {
                this.acquires.add(truncateTrace(Thread.currentThread().getStackTrace()));
            }
        }

        if (usage == 1) {
            synchronized (this) {
                if (this.sessionAcquired.compareAndSet(false, true)) {

            final SmbFile d = new SmbFile(f.getParent());
            final byte[] buf = new byte[1024];

            for (int ii = 0; ii < numIter; ii++) {

                synchronized (this) {
                    ltime = System.currentTimeMillis();
                    wait();
                }

                try {
                    final double r = Math.random();

     */
    @Override
    public final void received() {
        if (isAsync() && getStatus() == NtStatus.NT_STATUS_PENDING) {
            synchronized (this) {
                notifyAll();
            }
            return;
        }
        this.received = true;
        synchronized (this) {
            notifyAll();
        }
    }

    /**
     * {@inheritDoc}
     *

            }
        }
    }

    protected synchronized void doDisconnect(final boolean hard) throws IOException {
        doDisconnect(hard, false);
    }

    @Override
    protected synchronized boolean doDisconnect(final boolean hard, final boolean inUse) throws IOException {

            out.origin_ctx = null;
        }
    }

    void resolveSids0(final String authorityServerName, final CIFSContext tc, final jcifs.SID[] sids) throws CIFSException {
        synchronized (this.sidCache) {
            try (DcerpcHandle handle = DcerpcHandle.getHandle("ncacn_np:" + authorityServerName + "[\\PIPE\\lsarpc]", tc)) {
                String server = authorityServerName;

            }
        }

        public synchronized void recordSuccess(long responseTimeMs) {
            getCurrentBucket().recordSuccess(responseTimeMs);
        }

        public synchronized void recordFailure() {
            getCurrentBucket().recordFailure();
        }

        public synchronized WindowMetrics getMetrics() {
            long now = System.currentTimeMillis();

    }

    /**
     * Establishes RDMA connection to the remote server.
     *
     * @throws IOException if connection fails
     */
    public void connectRdma() throws IOException {
        synchronized (connectionLock) {
            if (rdmaConnection != null && rdmaConnection.isConnected()) {
                return;
            }

            try {
                rdmaConnection =