}

        // Check global rate limit
        if (!checkGlobalRateLimit()) {
            totalAttemptsBlocked.incrementAndGet();
            log.warn("Global rate limit exceeded, blocking attempt from {}", sourceIp);
            return false;
        }

        // Check per-account limit
        if (username != null) {

 *
 * <p>An instance may be called concurrently by multiple threads to process different entries.
 * Implementations of this interface should avoid performing blocking calls or synchronizing on
 * shared resources.
 *
 * @param <K> the most general type of keys this listener can listen for; for example {@code Object}
 *     if any key is acceptable

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3

import okio.IOException

/**
 * Returns the trailers that follow an HTTP response, blocking if they aren't ready yet.
 * Implementations of this interface should respond to [Call.cancel] by immediately throwing an
 * [IOException].
 *

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import org.jspecify.annotations.NullUnmarked;
import org.jspecify.annotations.Nullable;

/**
 * A bounded {@linkplain BlockingQueue blocking queue} backed by an array. This queue orders
 * elements FIFO (first-in-first-out). The head of the queue is that element that has been

    }
    CyclicBarrier barrier =
        new CyclicBarrier(
            6 // for the setter threads
                + 50 // for the listeners
                + 50 // for the blocking get threads,
                + 1); // for the main thread
    ExecutorService executor = newFixedThreadPool(barrier.getParties());
    AtomicReference<AbstractFuture<String>> currentFuture = Atomics.newReference();

    // thread because the task will block on the task latch after unblocking
    // the run latch.
    exec.execute(task);
    runLatch.await();
    assertEquals(1, listenerLatch.getCount());
    assertFalse(task.isDone());
    assertFalse(task.isCancelled());

    // Finish the task by unblocking the task latch.  Then wait for the
    // listener to be called by blocking on the listener latch.
    taskLatch.countDown();

   *
   * <p>Currently, this method is invoked while holding a lock. If an implementation of this method
   * blocks, it can prevent this service from changing state. If you need to performing a blocking
   * operation in order to trigger shutdown, consider instead registering a listener and
   * implementing {@code stopping}. Note, however, that {@code stopping} does not run at exactly the

            final int flags = oldFlags | ServerMessageBlock2.SMB2_FLAGS_SIGNED;
            SMBUtil.writeInt4(flags, data, offset + 16);

            // Create new Mac instance for thread safety without blocking other operations
            Mac mac;
            try {
                mac = createMacInstance();
            } catch (GeneralSecurityException e) {

 *
 * This class implements the TRANS_PEEK_NAMED_PIPE transaction which allows
 * reading data from a pipe without removing it, useful for checking if data
 * is available before performing a blocking read.
 */
public class TransPeekNamedPipe extends SmbComTransaction {

    private final int fid;

    /**
     * Constructs a TransPeekNamedPipe request to check the status of a named pipe.
     *

 *     failed connect attempts (such as trying the next [ConnectionSpec]), or as attempts that lost
 *     a race in fast follow-up.
 *
 *  4. If there's no existing connection, make a list of routes (which may require blocking DNS
 *     lookups) and attempt new connections to them. When failures occur, retries iterate the
 *     list of available routes.
 *