} finally {
                        this.connectionState.set(0);
                    }
                    throw se;
                } finally {
                    transport.notifyAll();
                }
            }
        }
    }

    /**
     * @param transport
     * @param sess
     * @param response
     * @throws IOException
     */

                    logger.debug("delay={}", delay);
                }
                Thread.sleep(delay);
            } while (delay > 2);

            synchronized (t) {
                t.notifyAll();
            }
            //System.out.println("numComplete=" + t.numComplete + ",numThreads=" + t.numThreads);
        }

        for (ti = 0; ti < t.numThreads; ti++) {
            threads[ti].join();

                        }
                        doSkip();
                    } else {
                        doRecv(response);
                        response.isReceived = true;
                        notifyAll();
                    }
                }
            } catch (final Exception ex) {
                final String msg = ex.getMessage();

            } catch (final SmbException se) {
                logoff(true);
                connectionState = 0;
                throw se;
            } finally {
                transport.notifyAll();
            }
        }
    }

    void logoff(final boolean inError) {
        synchronized (transport()) {

            if (connectionState != 2) { // not-connected
                return;

                    }
                }
            }
            inDfs = false;
            inDomainDfs = false;

            connectionState = 0;

            session.transport.notifyAll();
        }
    }

    @Override
    public String toString() {
        return "SmbTree[share=" + share + ",service=" + service + ",tid=" + tid + ",inDfs=" + inDfs + ",inDomainDfs=" + inDomainDfs

        synchronized (this) {
            notifyAll();
        }
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.util.transport.Response#exception(java.lang.Exception)
     */
    @Override
    public void exception(final Exception e) {
        this.exception = e;
        synchronized (this) {
            notifyAll();
        }
    }

    /**

      events.add(requestHeaders)
      notifyAll()
      return false
    }

    @Synchronized override fun onHeaders(
      streamId: Int,
      responseHeaders: List<Header>,
      last: Boolean,
    ): Boolean {
      assertThat(streamId).isEqualTo(2)
      assertThat(last).isTrue()
      events.add(responseHeaders)
      notifyAll()
      return false
    }

 *       wait();
 *     }
 *     V result = value;
 *     value = null;
 *     notifyAll();
 *     return result;
 *   }
 *
 *   public synchronized void set(V newValue) throws InterruptedException {
 *     while (value != null) {
 *       wait();
 *     }
 *     value = newValue;
 *     notifyAll();
 *   }
 * }
 * }
 *
 * <h3>{@code ReentrantLock}</h3>
 *

        return obj;
    }

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

    void cacheAddress(final Name hostName, final NbtAddress addr) {
        if (this.transportContext.getConfig().getNetbiosCachePolicy() == 0) {
            return;
        }

                        // responses
                        logoff(true, true);
                    }
                    throw se;
                } finally {
                    trans.notifyAll();
                }
            }
        }
    }

    /**
     * @param trans
     * @param chain
     * @param andxResponse
     * @throws SmbException
     */