when(address.getHostName()).thenReturn("testhost");

        transport = new SmbTransportImpl(context, address, 445, null, 0, false);
    }

    /**
     * Test that pre-auth integrity hash is properly synchronized
     */
    @Test
    @DisplayName("Pre-auth integrity hash should be thread-safe")
    void testPreauthHashThreadSafety() throws Exception {
        // Setup SMB3.1.1 negotiation

        try (SmbFileHandleImpl fh = ensureOpen()) {}
    }

    /**
     * @param file
     * @param openFlags
     * @return
     * @throws SmbException
     */
    synchronized SmbFileHandleImpl ensureOpen() throws CIFSException {
        if (this.handle == null || !this.handle.isValid()) {
            // one extra acquire to keep this open till the stream is released

            private final Object lock = new Object();
            private int watchCount = 0;

            @Override
            public List<FileNotifyInformation> watch() throws CIFSException {
                synchronized (lock) {
                    watchCount++;
                    try {
                        // Simulate some processing time
                        Thread.sleep(10);

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

			t.Errorf("Unexpected error: %v", dataErrsPerDisk[diskIndex])
		}

		if disk == nil {
			t.Errorf("Drive erroneously filtered, driveIndex: %d", diskIndex)
		}
	}

	// Test 2: Not synchronized modtime
	erasureDisks = s.getDisks()
	partsMetadataBackup := partsMetadata[0]
	partsMetadata[0].ModTime = partsMetadata[0].ModTime.Add(-1 * time.Hour)

	errs = make([]error, len(erasureDisks))

   *
   * <p>This method is not type-safe, as it may be called on elements that are not mutually
   * comparable.
   *
   * <p>This method is safe to use even when {@code elements} is a synchronized or concurrent
   * collection that is currently being modified by another thread.
   *
   * @throws ClassCastException if the elements are not mutually comparable

As the execution time is consumed mostly by waiting for <abbr title="Input and Output">I/O</abbr> operations, they call them "I/O bound" operations.

It's called "asynchronous" because the computer / program doesn't have to be "synchronized" with the slow task, waiting for the exact moment that the task finishes, while doing nothing, to be able to take the task result and continue the work.

    public void deleteBadWord(final String badWord) {
        suggester.indexer().deleteBadWord(badWord);
        refresh();
    }

    /**
     * Refreshes the suggest index.
     */
    public synchronized void refresh() {
        suggester.refresh();
        if (popularWordHelper != null) {
            popularWordHelper.clearCache();
        }
    }

    /**

                dataMap.put(fessConfig.getIndexFieldDocId(), systemHelper.generateDocId(dataMap));
            }

            languageHelper.updateDocument(dataMap);

            synchronized (docList) {
                docList.add(ingest(paramMap, dataMap));
                final long contentSize = indexingHelper.calculateDocumentSize(dataMap);
                docList.addContentSize(contentSize);

    public SmbClient() {
        super();
    }

    /**
    * Initializes the SMB client.
    * @see org.codelibs.fess.crawler.client.AbstractCrawlerClient#init()
    */
    @Override
    public synchronized void init() {
        if (smbAuthenticationHolder != null) {
            return;
        }

        if (logger.isDebugEnabled()) {
            logger.debug("Initializing SmbClient...");
        }