* @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) {

   *
   * @param queue the queue to be wrapped in a synchronized view
   * @return a synchronized view of the specified queue
   * @since 14.0
   */
  @J2ktIncompatible // Synchronized
  public static <E extends @Nullable Object> Queue<E> synchronizedQueue(Queue<E> queue) {
    return Synchronized.queue(queue, null);
  }

  /**

            }
        }
        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);

    }

    @Override
    public void onSuccess(String result) {
      synchronized (monitor) {
        assertFalse(wasCalled);
        wasCalled = true;
        assertEquals(value, result);
      }
    }

    @Override
    public synchronized void onFailure(Throwable t) {
      synchronized (monitor) {
        assertFalse(wasCalled);
        wasCalled = true;

        }

        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)) {

   *
   * @param table the table to be wrapped in a synchronized view
   * @return a synchronized view of the specified table
   * @since 22.0
   */
  @J2ktIncompatible // Synchronized
  public static <R extends @Nullable Object, C extends @Nullable Object, V extends @Nullable Object>
      Table<R, C, V> synchronizedTable(Table<R, C, V> table) {
    return Synchronized.table(table, null);
  }

     * @param size the maximum number of items to return
     * @return a PagingList containing the requested subset of mapping items
     */
    @Override
    public synchronized PagingList<CharMappingItem> selectList(final int offset, final int size) {
        if (mappingItemList == null) {
            reload(null);
        }

        if (offset >= mappingItemList.size() || offset < 0) {

    }

    @Override
    public synchronized void insert(final ProtwordsItem item) {
        try (ProtwordsUpdater updater = new ProtwordsUpdater(item)) {
            reload(updater);
        }
    }

    @Override
    public synchronized void update(final ProtwordsItem item) {
        try (ProtwordsUpdater updater = new ProtwordsUpdater(item)) {

     * @param timeout the maximum time to wait for the response in milliseconds
     * @throws IOException if an I/O error occurs during communication
     */
    public synchronized void sendrecv(final Request request, final Response response, long timeout) throws IOException {
        makeKey(request);
        response.isReceived = false;
        try {
            response_map.put(request, response);

  fun tearDown() {
    taskQueue.shutdown()
    taskQueue.idleLatch().await(10, TimeUnit.SECONDS)
  }

  @Synchronized fun sentPingCount(): Int = sentPingCount

  @Synchronized fun receivedPingCount(): Int = receivedPingCount

  @Synchronized fun receivedPongCount(): Int = receivedPongCount

  @Throws(IOException::class)
  override fun onReadMessage(text: String) {