Java Code Examples for java.util.concurrent.atomic.AtomicInteger#addAndGet()

@Override
public void handle(List<Integer> perBatchList,PartitionThreadEntity partitionThreadEntity,Map<String, ?> paramsMap){
    final AtomicInteger atomicInteger = (AtomicInteger) paramsMap.get("result");
    for (Integer value : perBatchList){

        LOGGER.trace(
                        "{},BatchNumber:[{}],CurrentListSize:[{}],EachSize:[{}],Name:[{}],TotalListCount:[{}]",
                        partitionThreadEntity.toString(),
                        partitionThreadEntity.getBatchNumber(),
                        partitionThreadEntity.getCurrentListSize(),
                        partitionThreadEntity.getEachSize(),
                        partitionThreadEntity.getName(),
                        partitionThreadEntity.getTotalListCount());
        atomicInteger.addAndGet(value);
    }

}
 

/**
 * Increments the counter denoted by counterName by the given value. The counter's value will only be written to the context if it exceeds bufferSize
 * 
 * @param groupName
 *            The name of the counter's group
 * @param counterName
 *            The name of the counter to increment
 * @param value
 *            The amount to increment the counter by
 * @param reporter
 *            The current task's context
 */
public void incrementValue(String groupName, String counterName, int value, StatusReporter reporter) {
    Map<String,AtomicInteger> group = counts.get(groupName);
    if (group == null) {
        group = new HashMap<>();
        counts.put(groupName, group);
    }
    
    if (group.containsKey(counterName)) {
        AtomicInteger val = group.get(counterName);
        
        if (val.get() > bufferSize && reporter != null) {
            reporter.getCounter(groupName, counterName).increment(val.getAndSet(0));
        }
        
        val.addAndGet(value);
    } else {
        group.put(counterName, new AtomicInteger(1));
    }
}
 

protected void removeChildSlaveRefCounts(VirtualFileSystemInode childInode, Map<String, AtomicInteger> childRefCounts) {
    if (!childRefCounts.isEmpty()) {
        for (Map.Entry<String, AtomicInteger> refEntry : childRefCounts.entrySet()) {
            AtomicInteger currentCount;
            currentCount = _slaveRefCounts.get(refEntry.getKey());
            if (currentCount == null) {
                // Shouldn't happen since we're removing a child, therefore we should have
                // counts for the slaves referenced by the child
                logger.error("Removing child {} from {} child contained a count of {} for slave {} but the slave has no count against this directory", childInode.getPath(), getPath(), refEntry.getValue().intValue(), refEntry.getKey());
                continue;
            }
            currentCount.addAndGet(-refEntry.getValue().intValue());
        }
        if (!isRoot()) {
            getParent().removeChildSlaveRefCounts(childInode, childRefCounts);
        }
    }
    commit();
}
 

@Group("g2")
@GroupThreads(2)
@Benchmark
public void queueDrainAtomic2() {
    AtomicInteger w = wip;
    if (w.getAndIncrement() == 0) {
        int missed = 1;

        for (;;) {
            counter++;
            
            missed = w.addAndGet(-missed);
            if (missed == 0) {
                break;
            }
        }
    }
}
 

@Override
public Object read(String s, AtomicInteger index, Context context) {
  AtomicInteger line = context.line;
  int startLine = line.get();
  int originalStartIndex = index.get();
  int startIndex = index.addAndGet(3);
  int endIndex = -1;
  
  if (s.charAt(startIndex) == '\n') {
    startIndex = index.incrementAndGet();
    line.incrementAndGet();
  }
  
  for (int i = startIndex; i < s.length(); i = index.incrementAndGet()) {
    char c = s.charAt(i);
    
    if (c == '\n') {
      line.incrementAndGet();
    } else if (c == '"' && s.length() > i + 2 && s.charAt(i + 1) == '"' && s.charAt(i + 2) == '"') {
      endIndex = i;
      index.addAndGet(2);
      break;
    }
  }
  
  if (endIndex == -1) {
    Results.Errors errors = new Results.Errors();
    errors.unterminated(context.identifier.getName(), s.substring(originalStartIndex), startLine);
    return errors;
  }

  s = s.substring(startIndex, endIndex);
  s = s.replaceAll("\\\\\\s+", "");
  s = StringValueReaderWriter.STRING_VALUE_READER_WRITER.replaceUnicodeCharacters(s);
  s = StringValueReaderWriter.STRING_VALUE_READER_WRITER.replaceSpecialCharacters(s);

  return s;
}
 

protected int getNumDivergents() {
    if (nodes.size() == 0)
        return 0;

    AtomicInteger cnt = new AtomicInteger(nodes.size() - 1);
    for (VirtualNode node : nodes.values()) {
        cnt.addAndGet(node.getNumDivergents());
    }
    return cnt.get();
}
 

CompletableFuture<Writer> writeAsync() {
  Objects.requireNonNull(asyncExecutor, "asyncExecutor == null");
  final Random r = new Random(seed);
  final int size = fileSize.getSizeInt();

  final CompletableFuture<Writer> returnFuture = new CompletableFuture<>();
  final AtomicInteger callCount = new AtomicInteger();
  final AtomicInteger n = new AtomicInteger();
  for(; n.get() < size; ) {
    final int offset = n.get();
    final int remaining = size - offset;
    final int length = Math.min(remaining, buffer.length);
    final boolean close = length == remaining;

    final ByteBuffer b = randomBytes(length, r);

    callCount.incrementAndGet();
    n.addAndGet(length);

    LOG.trace("writeAsync {}, offset={}, length={}, close? {}",
        fileName, offset, length, close);
    client.writeAsync(fileName, offset, close, b)
        .thenAcceptAsync(written -> Assert.assertEquals(length, (long)written), asyncExecutor)
        .thenRun(() -> {
          final int count = callCount.decrementAndGet();
          LOG.trace("writeAsync {}, offset={}, length={}, close? {}: n={}, callCount={}",
              fileName, offset, length, close, n.get(), count);
          if (n.get() == size && count == 0) {
            returnFuture.complete(this);
          }
        })
        .exceptionally(e -> {
          returnFuture.completeExceptionally(e);
          return null;
        });
  }
  return returnFuture;
}
 

@Test
public void test_stateful_start() {

    for (int i = 0; i < 100; i++) {
        final PUBLISH publish = createPublish(i, QoS.AT_LEAST_ONCE, "topic" + i);
        persistence.add("client" + i, false, publish, 100L, DISCARD, false, i % bucketCount);
    }

    persistence.stop();

    persistence.start();

    final ConcurrentHashMap<Integer, Map<Key, AtomicInteger>> queueSizeBuckets = persistence.getQueueSizeBuckets();

    final AtomicInteger counter = new AtomicInteger();

    for (final Map<Key, AtomicInteger> value : queueSizeBuckets.values()) {
        if (value != null) {
            for (final AtomicInteger count : value.values()) {
                if (count != null) {
                    counter.addAndGet(count.get());
                }
            }
        }
    }

    assertEquals(100, counter.get());
    assertEquals((Long.MAX_VALUE / 2) + 99, ClientQueuePersistenceSerializer.NEXT_PUBLISH_NUMBER.get());

}
 

private List<InsertValueContext> getInsertValueContexts(final List<Object> parameters, final AtomicInteger parametersOffset) {
    List<InsertValueContext> result = new LinkedList<>();
    for (Collection<ExpressionSegment> each : getSqlStatement().getAllValueExpressions()) {
        InsertValueContext insertValueContext = new InsertValueContext(each, parameters, parametersOffset.get());
        result.add(insertValueContext);
        parametersOffset.addAndGet(insertValueContext.getParametersCount());
    }
    return result;
}
 

private static List<String> handleNumberedInclude(List<String> lines, AtomicInteger lineNumber) {
    Include ia = Include.fromNumberedInclude(lines, 0, lines.get(lineNumber.getAndIncrement()));

    // Skip over the previously-included text.
    lineNumber.addAndGet(ia.endWithinBlock() - ia.startWithinBlock() + 1);

    return ia.asBracketedAsciiDocInclude();
}
 

private void submitInvokePoints() {
    AtomicInteger uploadCounter = new AtomicInteger(0);
    List<DataPoint> points = invokeDataQueue.peek();
    InvocationContext invocationContext = InvocationContextImpl.Factory.currentInstance();
    invocationContext.timeout(5000);
    while (points != null) {
        try {
            if (!points.isEmpty()) {
                LOGGER.debug(Thread.currentThread().getName() + "::uploading submitPoints ");

                CounterClientFactory.COUNTER_CLIENT.submitPoints(points);
                uploadCounter.addAndGet(points.size());
            }
            invokeDataQueue.remove(points);

            points = invokeDataQueue.peek();
        } catch (Throwable e) {
            // 上送出错
            LOGGER.error(e.getMessage(), e);
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug(Thread.currentThread().getName()
                        + " points:" + uploadCounter.get() + " uploaded before error, now  release the lock.");
            }
            return;
        }
    }

    if (LOGGER.isDebugEnabled()) {
        LOGGER.debug(Thread.currentThread().getName() + " no more points, total points:" + uploadCounter.get()
                + " uploaded, now release the lock.");
    }
    InvocationContextImpl.Factory.removeCurrentInstance();
}
 

private ParquetFileMetadata getParquetFileMetadata(FileAttributes file, AtomicInteger currentNumSplits, long maxSplits) throws IOException {
  final ParquetMetadata metadata =
    SingletonParquetFooterCache.readFooter(fs, file, ParquetMetadataConverter.NO_FILTER, maxFooterLength);
  final int numSplits = currentNumSplits.addAndGet(metadata.getBlocks().size());
  if (numSplits > maxSplits) {
    throw new TooManySplitsException(
      String.format("Too many splits encountered when processing parquet metadata at file %s, maximum is %d but encountered %d splits thus far.",
        file.getPath(), maxSplits, numSplits));
  }

  final MessageType schema = metadata.getFileMetaData().getSchema();

  Map<SchemaPath, OriginalType> originalTypeMap = Maps.newHashMap();
  schema.getPaths();
  for (String[] path : schema.getPaths()) {
    originalTypeMap.put(SchemaPath.getCompoundPath(path), getOriginalType(schema, path, 0));
  }

  List<RowGroupMetadata> rowGroupMetadataList = Lists.newArrayList();

  ArrayList<SchemaPath> ALL_COLS = new ArrayList<>();
  ALL_COLS.add(AbstractRecordReader.STAR_COLUMN);
  boolean autoCorrectCorruptDates = formatConfig.autoCorrectCorruptDates;
  ParquetReaderUtility.DateCorruptionStatus containsCorruptDates = ParquetReaderUtility.detectCorruptDates(metadata, ALL_COLS, autoCorrectCorruptDates);
  if(logger.isDebugEnabled()){
    logger.debug(containsCorruptDates.toString());
  }
  final Map<ColumnTypeMetadata.Key, ColumnTypeMetadata> columnTypeInfo = Maps.newHashMap();
  int rowGroupIdx = 0;
  for (BlockMetaData rowGroup : metadata.getBlocks()) {
    List<ColumnMetadata> columnMetadataList = Lists.newArrayList();
    long length = 0;
    for (ColumnChunkMetaData col : rowGroup.getColumns()) {
      ColumnMetadata columnMetadata;

      // statistics might just have the non-null counts with no min/max they might be
      // initialized to zero instead of null.
      // check statistics actually have non null values (or) column has all nulls.
      boolean statsAvailable = (col.getStatistics() != null && !col.getStatistics().isEmpty()
        && (col.getStatistics().hasNonNullValue()) || col.getStatistics().getNumNulls() ==
        rowGroup.getRowCount());

      Statistics<?> stats = col.getStatistics();
      String[] columnName = col.getPath().toArray();
      SchemaPath columnSchemaName = SchemaPath.getCompoundPath(columnName);
      ColumnTypeMetadata columnTypeMetadata =
          new ColumnTypeMetadata(columnName, col.getType(), originalTypeMap.get(columnSchemaName));

      columnTypeInfo.put(new ColumnTypeMetadata.Key(columnTypeMetadata.name), columnTypeMetadata);
      if (statsAvailable) {
        // Write stats only if minVal==maxVal. Also, we then store only maxVal
        Object mxValue = null;
        if (stats.genericGetMax() != null && stats.genericGetMin() != null &&
            stats.genericGetMax().equals(stats.genericGetMin())) {
          mxValue = stats.genericGetMax();
          if (containsCorruptDates == ParquetReaderUtility.DateCorruptionStatus.META_SHOWS_CORRUPTION
              && columnTypeMetadata.originalType == OriginalType.DATE) {
            mxValue = ParquetReaderUtility.autoCorrectCorruptedDate((Integer) mxValue);
          }
        }
        columnMetadata =
            new ColumnMetadata(columnTypeMetadata.name, mxValue, stats.getNumNulls());
      } else {
        // log it under trace to avoid lot of log entries.
        logger.trace("Stats are not available for column {}, rowGroupIdx {}, file {}",
            columnSchemaName, rowGroupIdx, file.getPath());
        columnMetadata = new ColumnMetadata(columnTypeMetadata.name,null, null);
      }
      columnMetadataList.add(columnMetadata);
      length += col.getTotalSize();
    }

    RowGroupMetadata rowGroupMeta =
        new RowGroupMetadata(rowGroup.getStartingPos(), length, rowGroup.getRowCount(),
            getHostAffinity(fs, file, rowGroup.getStartingPos(), length), columnMetadataList);

    rowGroupMetadataList.add(rowGroupMeta);
    rowGroupIdx++;
  }

  return new ParquetFileMetadata(file, file.size(), rowGroupMetadataList, columnTypeInfo);
}
 

@Override
public CircularList<Host> getVotingHosts() {
    if (votingHosts.getSize() == 0) {
        if(effectiveVotingSize % 2 == 0) {
            throw new IllegalStateException("Cannot do voting with even number of nodes for voting");
        }
        List<HostToken> allHostTokens = tokenMapSupplier.getTokens(ImmutableSet.copyOf(hostSupplier.getHosts()));
        if (allHostTokens.size() < MIN_VOTING_SIZE) {
            throw new IllegalStateException(String.format("Cannot perform voting with less than %d nodes", MIN_VOTING_SIZE));
        }
        // Total number of hosts present per rack
        Map<String, Long> numHostsPerRack = allHostTokens.stream().map(ht -> ht.getHost().getRack()).collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
        AtomicInteger numHostsRequired = new AtomicInteger(effectiveVotingSize);
        // Map to keep track of number of hosts to take for voting from this rack
        Map<String, Integer> numHosts = new HashMap<>();
        // Sort racks to get the same order
        List<String> racks = numHostsPerRack.keySet().stream().sorted(Comparator.comparing(String::toString)).collect(Collectors.toList());
        for(String rack: racks) {
            // Take as many hosts as you can from this rack.
            int v = (int) Math.min(numHostsRequired.get(), numHostsPerRack.get(rack));
            numHostsRequired.addAndGet(-v);
            numHosts.put(rack, v);
            calculatedVotingSize.addAndGet(v);
        }
        if(calculatedVotingSize.get() % 2 == 0) {
            throw new IllegalStateException("Could not construct voting pool. Min number of hosts not met!");
        }
        Map<String, List<HostToken>> rackToHostToken = allHostTokens.stream()
                .collect(Collectors.groupingBy(ht -> ht.getHost().getRack()));
        // Get the final list of voting hosts
        List<Host> finalVotingHosts = rackToHostToken.entrySet().stream()
                // Sorting on token to get hosts deterministically.
                .sorted(Comparator.comparing(Map.Entry::getKey))
                .flatMap(e -> {
                    List<HostToken> temp = e.getValue();
                    temp.sort(HostToken::compareTo);
                    return temp.subList(0, numHosts.get(e.getKey())).stream();
                })
                .map(ht -> ht.getHost())
                .collect(Collectors.toList());
        votingHosts.swapWithList(finalVotingHosts);
    }
    return votingHosts;
}
 

private void animate() {
  final int height = getPreferredSize().height;
  final int frameCount = 10;
  final boolean toClose = isShowing();


  final AtomicInteger i = new AtomicInteger(-1);
  final Alarm animator = new Alarm(myDisposable);
  final Runnable runnable = new Runnable() {
    @Override
    public void run() {
      int state = i.addAndGet(1);

      double linearProgress = (double)state / frameCount;
      if (toClose) {
        linearProgress = 1 - linearProgress;
      }
      myLayout.myPhase = (1 - Math.cos(Math.PI * linearProgress)) / 2;
      Window window = getPeer().getWindow();
      Rectangle bounds = window.getBounds();
      bounds.height = (int)(height * myLayout.myPhase);

      window.setBounds(bounds);

      if (state == 0 && !toClose && window.getOwner() != null) {
        consulo.ui.Window uiWindow = TargetAWT.from(window.getOwner());
        IdeFrame ideFrame = uiWindow.getUserData(IdeFrame.KEY);
        if(ideFrame != null) {
          WindowManager.getInstance().requestUserAttention(ideFrame, true);
        }
      }

      if (state < frameCount) {
        animator.addRequest(this, 10);
      }
      else if (toClose) {
        MessageDialog.super.dispose();
      }
    }
  };
  animator.addRequest(runnable, 10, ModalityState.stateForComponent(getRootPane()));
}
 

@Test
public void testConcurrentSplitAssignment() {
	try {
		final int NUM_THREADS = 10;
		final int NUM_SPLITS = 500;
		final int SUM_OF_IDS = (NUM_SPLITS-1) * (NUM_SPLITS) / 2;
		
		Set<InputSplit> splits = new HashSet<InputSplit>();
		for (int i = 0; i < NUM_SPLITS; i++) {
			splits.add(new GenericInputSplit(i, NUM_SPLITS));
		}
		
		final DefaultInputSplitAssigner ia = new DefaultInputSplitAssigner(splits);
		
		final AtomicInteger splitsRetrieved = new AtomicInteger(0);
		final AtomicInteger sumOfIds = new AtomicInteger(0);
		
		Runnable retriever = new Runnable() {
			
			@Override
			public void run() {
				String host = "";
				GenericInputSplit split;
				while ((split = (GenericInputSplit) ia.getNextInputSplit(host, 0)) != null) {
					splitsRetrieved.incrementAndGet();
					sumOfIds.addAndGet(split.getSplitNumber());
				}
			}
		};
		
		// create the threads
		Thread[] threads = new Thread[NUM_THREADS];
		for (int i = 0; i < NUM_THREADS; i++) {
			threads[i] = new Thread(retriever);
			threads[i].setDaemon(true);
		}
		
		// launch concurrently
		for (int i = 0; i < NUM_THREADS; i++) {
			threads[i].start();
		}
		
		// sync
		for (int i = 0; i < NUM_THREADS; i++) {
			threads[i].join(5000);
		}
		
		// verify
		for (int i = 0; i < NUM_THREADS; i++) {
			if (threads[i].isAlive()) {
				fail("The concurrency test case is erroneous, the thread did not respond in time.");
			}
		}
		
		assertEquals(NUM_SPLITS, splitsRetrieved.get());
		assertEquals(SUM_OF_IDS, sumOfIds.get());
		
		// nothing left
		assertNull(ia.getNextInputSplit("", 0));
	}
	catch (Exception e) {
		e.printStackTrace();
		fail(e.getMessage());
	}
}
 

/** Quorum sends transaction with single public recipient key */
@Test
public void sendToSingleRecipientUntilFailureOrMaxReached() {
    LOGGER.info("stress test starting");

    final Party firstParty = partyHelper.findByAlias("A");
    final Party secondParty = partyHelper.findByAlias("B");
    byte[] transactionData = utils.createTransactionData();

    final AtomicInteger sendCounter = new AtomicInteger(0);
    final AtomicInteger invalidResults = new AtomicInteger(0);

    final List<Thread> stressThreads = new ArrayList<>();
    for (int i = 0; i < THREAD_COUNT; i++) {
        final Thread stressThread =
                new Thread(
                        () -> {
                            int currentCount = sendCounter.incrementAndGet();
                            while (currentCount < MAX_COUNT) {
                                final SendRequest sendRequest = new SendRequest();
                                sendRequest.setFrom(firstParty.getPublicKey());
                                sendRequest.setTo(secondParty.getPublicKey());
                                sendRequest.setPayload(transactionData);

                                try (Response response =
                                        client.target(firstParty.getQ2TUri())
                                                .path(SEND_PATH)
                                                .request()
                                                .post(Entity.entity(sendRequest, MediaType.APPLICATION_JSON))) {

                                    if (response.getStatus() != 201) {
                                        LOGGER.info("Response is not 201. MessageCount=" + currentCount);
                                        sendCounter.addAndGet(MAX_COUNT);
                                        invalidResults.incrementAndGet();
                                    }
                                }

                                currentCount = sendCounter.incrementAndGet();
                                if (currentCount % 1000 == 0) {
                                    LOGGER.info("currentCount={}", currentCount);
                                }
                            }
                        });
        stressThread.start();
        stressThreads.add(stressThread);
    }

    // wait for stress threads to finish
    for (int i = 0; i < THREAD_COUNT; i++) {
        try {
            stressThreads.get(i).join();
        } catch (InterruptedException e) {
            LOGGER.error("Error while waiting for clients to stop.", e);
        }
    }
    LOGGER.info("stress test finished");
    assertThat(invalidResults.get()).isEqualTo(0);
}
 

/**
 * Gets and validates the content from the specified <code>url</code>.
 * 
 * @param url
 *            <code>URL</code> where to get the content from.
 * @param timeout
 *            maximum time to wait before abandoning the connection in milliseconds
 * @param headersMap
 *            headers to be sent when making the request to the specified URL
 * @return content read from the specified <code>url</code>
 */
public Set<NoteItem> getContent(String url, int timeoutInMillis, RequestOptions options) {
    CloseableHttpClient client = null;
    CloseableHttpResponse response = null;
    try {
        URL source = build(url, options);
        HttpGet request = new HttpGet(source.toURI());
        for (Entry<String, String> entry : options.headers().entrySet()) {
            request.addHeader(entry.getKey(), entry.getValue());
        }

        client = buildClient(timeoutInMillis, source);
        response = client.execute(request);

        InputStream contentStream = null;
        ByteArrayOutputStream baos = null;
        try {
            contentStream = response.getEntity().getContent();
            baos = new ByteArrayOutputStream();
            AtomicInteger counter = new AtomicInteger();
            byte[] buffer = new byte[1024];
            int offset = 0;
            long startTime = System.currentTimeMillis();
            while ((offset = contentStream.read(buffer)) != -1) {
                counter.addAndGet(offset);
                if (counter.get() > allowedContentSizeInBytes) {
                    throw new ExternalContentTooLargeException(
                            "Content from url " + url + " is larger then " + this.allowedContentSizeInBytes);
                }
                long now = System.currentTimeMillis();
                if (startTime + timeoutInMillis < now) {
                    throw new IOException("Too much time spent reading url: " + url);
                }
                baos.write(buffer, 0, offset);
            }
            Calendar calendar = new CalendarBuilder().build(new ByteArrayInputStream(baos.toByteArray()));
            this.postProcess(calendar);

            Set<NoteItem> externalItems = converter.asItems(calendar);

            validate(externalItems);

            return externalItems;
        } finally {
            close(contentStream);
            close(baos);
        }
    } catch (IOException | URISyntaxException | ParserException e) {
        throw new ExternalContentInvalidException(e);
    } finally {
        close(response);
        close(client);
    }
}
 

@Test
public void testConcurrentSplitAssignmentForSingleHost() {
	try {
		final int NUM_THREADS = 10;
		final int NUM_SPLITS = 500;
		final int SUM_OF_IDS = (NUM_SPLITS-1) * (NUM_SPLITS) / 2;
		
		// load some splits
		Set<LocatableInputSplit> splits = new HashSet<LocatableInputSplit>();
		for (int i = 0; i < NUM_SPLITS; i++) {
			splits.add(new LocatableInputSplit(i, "testhost"));
		}
		
		final LocatableInputSplitAssigner ia = new LocatableInputSplitAssigner(splits);
		
		final AtomicInteger splitsRetrieved = new AtomicInteger(0);
		final AtomicInteger sumOfIds = new AtomicInteger(0);
		
		Runnable retriever = new Runnable() {
			
			@Override
			public void run() {
				LocatableInputSplit split;
				while ((split = ia.getNextInputSplit("testhost", 0)) != null) {
					splitsRetrieved.incrementAndGet();
					sumOfIds.addAndGet(split.getSplitNumber());
				}
			}
		};
		
		// create the threads
		Thread[] threads = new Thread[NUM_THREADS];
		for (int i = 0; i < NUM_THREADS; i++) {
			threads[i] = new Thread(retriever);
			threads[i].setDaemon(true);
		}
		
		// launch concurrently
		for (int i = 0; i < NUM_THREADS; i++) {
			threads[i].start();
		}
		
		// sync
		for (int i = 0; i < NUM_THREADS; i++) {
			threads[i].join(5000);
		}
		
		// verify
		for (int i = 0; i < NUM_THREADS; i++) {
			if (threads[i].isAlive()) {
				fail("The concurrency test case is erroneous, the thread did not respond in time.");
			}
		}
		
		assertEquals(NUM_SPLITS, splitsRetrieved.get());
		assertEquals(SUM_OF_IDS, sumOfIds.get());
		
		// nothing left
		assertNull(ia.getNextInputSplit("testhost", 0));
		
		assertEquals(0, ia.getNumberOfRemoteAssignments());
		assertEquals(NUM_SPLITS, ia.getNumberOfLocalAssignments());
	}
	catch (Exception e) {
		e.printStackTrace();
		fail(e.getMessage());
	}
}
 

@Test public void testCheckedBiConsumer_andThen() throws Throwable {
  AtomicInteger sum = new AtomicInteger();
  CheckedBiConsumer<Integer, Integer, Throwable> consumer = (a, b) -> sum.addAndGet(a + b);
  consumer.andThen(consumer).accept(1, 2);
  assertThat(sum.get()).isEqualTo(6);
}
 

public int get(String name) {

		synchronized (this) {
			
			AtomicInteger seqNum = sequenceMap.get(name);
			if (seqNum == null) {

				sequenceMap.put(name, new AtomicInteger(0));
				dao.setSequence(name, 0);
				return 0;
				
			} else {
				
				int num = seqNum.addAndGet(1);
				dao.setSequence(name,  num);
				return num;
				
			}
			
		}
	}