final int iterationsPerThread = 100;
        final CountDownLatch startLatch = new CountDownLatch(1);
        final CountDownLatch endLatch = new CountDownLatch(threadCount);
        final AtomicInteger errorCount = new AtomicInteger(0);

        // Set initial values
        testRule.setRuleId("concurrentRule");
        TestResponseProcessor processor = new TestResponseProcessor();
        testRule.setResponseProcessor(processor);

  fun testLoggingLevels() {
    enableTls()

    val testHandler =
      object : Handler() {
        val calls = mutableMapOf<String, AtomicInteger>()

        override fun publish(record: LogRecord) {
          calls
            .getOrPut(record.loggerName) { AtomicInteger(0) }
            .incrementAndGet()
        }

        override fun flush() {
        }

        override fun close() {

     * Used to enforce maximum concurrent crawler limits.
     *
     * @return the number of currently running crawler jobs
     */
    protected int getRunningJobCount() {
        final AtomicInteger counter = new AtomicInteger(0);
        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        ComponentUtil.getComponent(ScheduledJobBhv.class).selectCursor(cb -> {
            cb.query().setAvailable_Equal(Constants.T);

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jcifs.CIFSContext;
import jcifs.Configuration;
import jcifs.SmbSession;
import jcifs.SmbTransport;

    @DisplayName("readFully(): reads across multiple partial reads")
    void readFully_readsAll() throws Exception {
        SmbRandomAccessFile raf = spy(newInstance("r", false, false, false));
        AtomicInteger calls = new AtomicInteger();
        doAnswer(inv -> {
            int len = inv.getArgument(2);
            // First call returns len-1, second returns 1
            return calls.getAndIncrement() == 0 ? Math.max(1, len - 1) : 1;

    private static class TestSystemHelper extends SystemHelper {
        private boolean forceStop = false;
        private boolean componentAvailable = true;
        private final AtomicInteger cpuLoadCallCount = new AtomicInteger(0);

        @Override
        public boolean isForceStop() {
            return forceStop;
        }

        @Override
        public void setForceStop(boolean forceStop) {

      if (method.isAnnotationPresent(Empty.class)) {
        builder.put(method.getReturnType(), method);
      }
    }
    EMPTY_GENERATORS = builder.buildOrThrow();
  }

  private final AtomicInteger freshness = new AtomicInteger(1);
  private final ListMultimap<Class<?>, Object> sampleInstances = ArrayListMultimap.create();

  /**
   * The freshness level at which the {@link Empty @Empty} annotated method was invoked to generate

import java.util.concurrent.ExecutorService
import java.util.concurrent.RejectedExecutionException
import java.util.concurrent.TimeUnit.MILLISECONDS
import java.util.concurrent.atomic.AtomicBoolean
import java.util.concurrent.atomic.AtomicInteger
import okhttp3.Call
import okhttp3.Callback
import okhttp3.EventListener
import okhttp3.Interceptor
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.Response

import java.net.InetSocketAddress
import java.net.Proxy
import java.security.cert.X509Certificate
import java.util.Arrays
import java.util.concurrent.CountDownLatch
import java.util.concurrent.atomic.AtomicInteger
import java.util.concurrent.atomic.AtomicReference
import javax.net.ssl.HostnameVerifier
import javax.net.ssl.SSLPeerUnverifiedException
import javax.net.ssl.SSLSession
import javax.net.ssl.X509TrustManager

    }
}
```

### 4.3 Channel Manager
```java
package jcifs.internal.smb2.multichannel;

import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class ChannelManager {
    private final CIFSContext context;
    private final SmbSession session;
    private final Map<String, ChannelInfo> channels;