private final int batchSize = 10;
    private final long batchTimeout = 100;  // 100ms
    
    public void addNotification(WitnessNotification notification) {
        synchronized (pendingNotifications) {
            pendingNotifications.offer(notification);
            
            if (pendingNotifications.size() >= batchSize) {
                processBatch();
            }

  private class RecordingPushObserver :
    PushObserver,
    Lockable {
    val events = mutableListOf<Any>()

    @Synchronized fun takeEvent(): Any {
      while (events.isEmpty()) {
        wait()
      }
      return events.removeAt(0)
    }

    @Synchronized override fun onRequest(
      streamId: Int,
      requestHeaders: List<Header>,
    ): Boolean {

        .suppressing(suppressForLinkedHashMap())
        .createTestSuite();
  }

  /**
   * Tests regular NavigableMap behavior of synchronizedNavigableMap(treeMap); does not test the
   * fact that it's synchronized.
   */
  public Test testsForSynchronizedNavigableMap() {
    return NavigableMapTestSuiteBuilder.using(
            new TestStringSortedMapGenerator() {
              @Override

                resp.setContentLength(0);
                resp.flushBuffer();
                return null;
            }
        }

        return ntlm;
    }

    private synchronized NtlmChallenge getChallengeForDomain(final String domain) throws UnknownHostException, ServletException {
        if (domain == null) {
            throw new ServletException("A domain was not specified");
        }

                                    + now
                                    + ", lastUpdated = " + lastUpdated + "). Please verify that the clocks of all"
                                    + " deploying machines are reasonably synchronized.");
                    versioning.setLastUpdated(now);
                    changed = true;
                }
            }
        }

        if (changed) {

     *
     * @param sessionId the crawler session ID that has finished processing
     */
    public void addFinishedSessionId(final String sessionId) {
        synchronized (finishedSessionIdList) {
            finishedSessionIdList.add(sessionId);
        }
    }

    /**
     * Deletes all data associated with a specific crawler session.

     *            if there is a DCE/RPC protocol error
     * @throws IOException
     *            if there is an I/O error during binding
     */
    public void bind() throws DcerpcException, IOException {
        synchronized (this) {
            try {
                this.state = 1;
                final DcerpcMessage bind = new DcerpcBind(this.binding, this);
                sendrecv(bind);
            } catch (final IOException ioe) {

    public int available() throws IOException {
      return (int) min(in.available(), left);
    }

    // it's okay to mark even if mark isn't supported, as reset won't work
    @Override
    public synchronized void mark(int readLimit) {
      in.mark(readLimit);
      mark = left;
    }

    @Override
    public int read() throws IOException {
      if (left == 0) {
        return -1;
      }

    /**
     * Ensures that the file handle is open and returns it.
     *
     * @return the open file handle
     * @throws CIFSException if an error occurs opening the file
     */
    protected synchronized SmbFileHandleImpl ensureOpen() throws CIFSException {
        if (!isOpen()) {
            // one extra acquire to keep this open till the stream is released

     *
     * @return The configured SPNEGO authenticator instance
     * @throws SsoLoginException if SPNEGO initialization fails
     */
    protected synchronized org.codelibs.spnego.SpnegoAuthenticator getAuthenticator() {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();