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

  /**

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

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

  /**

     */
    public int getMessageCount() {
        synchronized (messagesLock) {
            return messages != null ? messages.size() : 0;
        }
    }

    /**
     * Clears all messages in this session and updates the last accessed timestamp.
     */
    public void clearMessages() {
        synchronized (messagesLock) {
            if (messages != null) {
                messages.clear();

   * 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

  }

  @Override
  public int size() {
    synchronized (lock) {
      return cachingHashMap.size();
    }
  }

  @Override
  public boolean isEmpty() {
    synchronized (lock) {
      return cachingHashMap.isEmpty();
    }
  }

  @Override
  public @Nullable V get(@Nullable Object key) {
    Timestamped<V> value;
    synchronized (lock) {
      checkNotNull(key);

                        // Access is synchronized internally in the actual implementation
                        // Here we just verify no concurrent modification exceptions occur
                        String url = "http://example.com/thread" + threadIndex + "/doc" + j;
                        // Simulate the synchronized access that happens in deleteDocument()
                        synchronized (mockCallback) {

    }

    @Override
    public void onSuccess(String result) {
      synchronized (monitor) {
        assertFalse(wasCalled);
        wasCalled = true;
        assertThat(result).isEqualTo(value);
      }
    }

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

        }
      }
    }

    synchronized void write(int b) throws IOException {
      update(1);
      out.write(b);
    }

    synchronized void write(byte[] b, int off, int len) throws IOException {
      update(len);
      out.write(b, off, len);
    }

    synchronized void close() throws IOException {
      out.close();
    }

    synchronized void flush() throws IOException {

    }

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

    @Override
    public synchronized void update(final KuromojiItem item) {
        try (KuromojiUpdater updater = new KuromojiUpdater(item)) {