Java ConcurrentLinkedQueue.isEmpty方法代码示例

import java.util.concurrent.ConcurrentLinkedQueue; //导入方法依赖的package包/类
public AnalysisResults simpleAnalyze(String text) {
    final AnalyzeOptions parameters = new AnalyzeOptions.Builder()
            .text(text)
            .language("en")
            .features(features)
            .build();
    final ConcurrentLinkedQueue<AnalysisResults> queue = new ConcurrentLinkedQueue<>();
    new Thread(new Runnable() {
        @Override
        public void run() {
            queue.add(service
                    .analyze(parameters)
                    .execute());
        }
    }).start();
    while (queue.isEmpty())
        try {
            Thread.sleep(100, 0);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    //System.out.println(response);
    return queue.peek();
}
 

import java.util.concurrent.ConcurrentLinkedQueue; //导入方法依赖的package包/类
/**
 * Process all incoming entity update requests.
 */
private void processUpdate() {
    // TODO: Remove memory leak for updates that belong to non-existing entities
    for(Map.Entry<Integer, Entity> e : entities.entrySet()) {
        Entity entity = e.getValue();
        ConcurrentLinkedQueue<EntityUpdate> updates = updateMap.get(entity.getId());

        while(!updates.isEmpty()) {
            updates.poll().update(entity);
        }
    }
}
 

import java.util.concurrent.ConcurrentLinkedQueue; //导入方法依赖的package包/类
public void clean() {
    // the lock protects removal from a concurrent put which could otherwise mutate the
    // queue after it has been removed from the map
    synchronized (unsent) {
        Iterator<ConcurrentLinkedQueue<ClientRequest>> iterator = unsent.values().iterator();
        while (iterator.hasNext()) {
            ConcurrentLinkedQueue<ClientRequest> requests = iterator.next();
            if (requests.isEmpty())
                iterator.remove();
        }
    }
}
 

import java.util.concurrent.ConcurrentLinkedQueue; //导入方法依赖的package包/类
public boolean hasRequests(Node node) {
    ConcurrentLinkedQueue<ClientRequest> requests = unsent.get(node);
    return requests != null && !requests.isEmpty();
}
 

import java.util.concurrent.ConcurrentLinkedQueue; //导入方法依赖的package包/类
public static void testCacheMultiThreaded(final BlockCache toBeTested,
    final int blockSize, final int numThreads, final int numQueries,
    final double passingScore) throws Exception {

  Configuration conf = new Configuration();
  MultithreadedTestUtil.TestContext ctx = new MultithreadedTestUtil.TestContext(
      conf);

  final AtomicInteger totalQueries = new AtomicInteger();
  final ConcurrentLinkedQueue<HFileBlockPair> blocksToTest = new ConcurrentLinkedQueue<HFileBlockPair>();
  final AtomicInteger hits = new AtomicInteger();
  final AtomicInteger miss = new AtomicInteger();

  HFileBlockPair[] blocks = generateHFileBlocks(numQueries, blockSize);
  blocksToTest.addAll(Arrays.asList(blocks));

  for (int i = 0; i < numThreads; i++) {
    TestThread t = new MultithreadedTestUtil.RepeatingTestThread(ctx) {
      @Override
      public void doAnAction() throws Exception {
        if (!blocksToTest.isEmpty()) {
          HFileBlockPair ourBlock = blocksToTest.poll();
          // if we run out of blocks to test, then we should stop the tests.
          if (ourBlock == null) {
            ctx.setStopFlag(true);
            return;
          }
          toBeTested.cacheBlock(ourBlock.blockName, ourBlock.block);
          Cacheable retrievedBlock = toBeTested.getBlock(ourBlock.blockName,
              false, false, true);
          if (retrievedBlock != null) {
            assertEquals(ourBlock.block, retrievedBlock);
            toBeTested.evictBlock(ourBlock.blockName);
            hits.incrementAndGet();
            assertNull(toBeTested.getBlock(ourBlock.blockName, false, false, true));
          } else {
            miss.incrementAndGet();
          }
          totalQueries.incrementAndGet();
        }
      }
    };
    t.setDaemon(true);
    ctx.addThread(t);
  }
  ctx.startThreads();
  while (!blocksToTest.isEmpty() && ctx.shouldRun()) {
    Thread.sleep(10);
  }
  ctx.stop();
  if (hits.get() / ((double) hits.get() + (double) miss.get()) < passingScore) {
    fail("Too many nulls returned. Hits: " + hits.get() + " Misses: "
        + miss.get());
  }
}