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

  /**

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

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

  /**

   * 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

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

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

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

    }

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

        getProperties().list(out);
    }

    @Override
    public synchronized void load(final InputStream inStream) throws IOException {
        final Properties prop = new Properties();
        lastModified = propertiesFile.lastModified();
        prop.load(inStream);
        properties = prop;
    }

    @Override
    public synchronized void load(final Reader reader) throws IOException {

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