/** Returns true if the element is native. */
  public final boolean isNative() {
    return Modifier.isNative(getModifiers());
  }

  /** Returns true if the method is synchronized. */
  public final boolean isSynchronized() {
    return Modifier.isSynchronized(getModifiers());
  }

  /** Returns true if the field is volatile. */
  final boolean isVolatile() {
    return Modifier.isVolatile(getModifiers());
  }

   * greater than the max size if a background deletion is pending.
   */
  @Synchronized
  @Throws(IOException::class)
  fun size(): Long {
    initialize()
    return size
  }

  @Synchronized
  @Throws(IOException::class)
  internal fun completeEdit(
    editor: Editor,
    success: Boolean,
  ) {
    val entry = editor.entry

     */
    public synchronized void clear() {
        timeoutTaskList.clear();
    }

    /**
     * Adds a {@link TimeoutTarget}.
     *
     * @param timeoutTarget the target
     * @param timeout the timeout duration
     * @param permanent whether the task is permanent
     * @return the {@link TimeoutTask}
     */

    startTask();
    try {
      command.run();
    } finally {
      endTask();
    }
  }

  @Override
  public boolean isShutdown() {
    synchronized (lock) {
      return shutdown;
    }
  }

  @Override
  public void shutdown() {
    synchronized (lock) {
      shutdown = true;
      if (runningTasks == 0) {
        lock.notifyAll();
      }
    }
  }

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

   * execution of tasks will stop until a call to this method is made.
   */
  @Override
  public void execute(Runnable task) {
    checkNotNull(task);
    Runnable submittedTask;
    long oldRunCount;
    synchronized (queue) {
      // If the worker is already running (or execute() on the delegate returned successfully, and
      // the worker has yet to start) then we don't need to start the worker.

    }

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