this.client = client;
    this.queue = new LinkedBlockingQueue<>(queueLimit);
    this.hostLimit = hostLimit;
  }

  private void parallelDrainQueue(int threadCount) {
    ExecutorService executor = Executors.newFixedThreadPool(threadCount);
    for (int i = 0; i < threadCount; i++) {
      executor.execute(() -> {
        try {
          drainQueue();
        } catch (Throwable e) {
          e.printStackTrace();
        }

import static com.google.common.graph.TestUtil.assertStronglyEquivalent;
import static com.google.common.truth.Truth.assertThat;
import static java.util.concurrent.Executors.newFixedThreadPool;
import static org.junit.Assert.assertThrows;

import com.google.common.collect.ImmutableList;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.CyclicBarrier;

import static com.google.common.util.concurrent.SneakyThrows.sneakyThrow;
import static java.util.concurrent.Executors.callable;
import static java.util.concurrent.Executors.newFixedThreadPool;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.NANOSECONDS;
import static java.util.concurrent.TimeUnit.SECONDS;
import static org.junit.Assert.assertThrows;

    private CountDownLatch endLatch;

    @Test
    void testTransferProgressedWithPrintResourceNames() throws Exception {
        int size = 1000;
        ExecutorService service = Executors.newFixedThreadPool(size * 2);
        try {
            startLatch = new CountDownLatch(size);
            endLatch = new CountDownLatch(size);
            Map<String, String> output = new ConcurrentHashMap<String, String>();

        session.setParallel(parallel);
        for (ProjectSegment segment : projectBuilds) {
            segment.getSession().setParallel(parallel);
        }
        ExecutorService executor = Executors.newFixedThreadPool(nThreads, new BuildThreadFactory());
        CompletionService<ProjectSegment> service = new ExecutorCompletionService<>(executor);

        for (TaskSegment taskSegment : taskSegments) {

        final CountDownLatch startLatch = new CountDownLatch(1);
        final CountDownLatch endLatch = new CountDownLatch(threadCount);

        ExecutorService executor = Executors.newFixedThreadPool(threadCount);

        for (int i = 0; i < threadCount; i++) {
            executor.submit(new Runnable() {
                @Override
                public void run() {
                    try {

     */
    @Test
    public void testConcurrentBufferOperations() throws Exception {
        // Given
        int threadCount = 10;
        int opsPerThread = 100;
        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
        CountDownLatch startLatch = new CountDownLatch(1);
        CountDownLatch endLatch = new CountDownLatch(threadCount);
        AtomicInteger successCount = new AtomicInteger(0);

        final AtomicInteger errorCount = new AtomicInteger(0);

        testTransformer.setName("concurrentName");

        ExecutorService executor = Executors.newFixedThreadPool(threadCount);

        for (int i = 0; i < threadCount; i++) {
            final int threadId = i;
            executor.submit(new Runnable() {
                @Override
                public void run() {

import static com.google.common.graph.TestUtil.assertStronglyEquivalent;
import static com.google.common.truth.Truth.assertThat;
import static java.util.concurrent.Executors.newFixedThreadPool;
import static org.junit.Assert.assertThrows;

import com.google.common.collect.ImmutableList;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.CyclicBarrier;

                logger.warn("Failed to create system properties file.", e);
            }
        }

        int totalCount = 0;
        int count = 1;
        final ExecutorService executorService = Executors.newFixedThreadPool(options.numOfThreads);
        try {
            while (count != 0) {
                count = ComponentUtil.getThumbnailManager().generate(executorService, options.cleanup);
                totalCount += count;