@Override public boolean contains(Object element) { return underlyingQueue.contains(element); }
processor.run(); Assert.assertTrue("Did not process the first write request", processedRequests.contains(firstCommittedReq)); for (Request r : allReads) { Assert.assertTrue("Processed read request", !processedRequests.contains(r)); processedRequests.containsAll(allReads)); Assert.assertTrue("Did not process the second write request", processedRequests.contains(secondCommittedReq)); for (Request r : waitingCommittedRequests) { Assert.assertTrue("Processed additional committed request", !processedRequests.contains(r));
private void removeRequest() { mCancelerManager.removeCancel(mRequest); if (mQueue.contains(mWork)) { mQueue.remove(mWork); } } }
Assert.assertTrue(processedRequests.contains(otherSessionCommittedReq));
@VisibleForTesting boolean isChunkInPool(int chunkId) { Chunk c = getChunk(chunkId); if (c==null) { return false; } // chunks that are from pool will return true chunk reference not null if (dataChunksPool != null && dataChunksPool.reclaimedChunks.contains(c)) { return true; } else if (indexChunksPool != null && indexChunksPool.reclaimedChunks.contains(c)) { return true; } return false; }
@Override public void onFinish(final int what) { if (mQueue.contains(mWork)) { mQueue.remove(mWork); } HandlerDelivery.getInstance().post(new Runnable() { @Override public void run() { mCallback.onFinish(what); } }); } }
try { for (final FileInfo file : listing) { if (!queue.contains(file) && !processing.contains(file)) { if (!queue.offer(file)) { break;
final int size = Math.min(q.remainingCapacity(), SIZE); final Object[] elts = new Object[size]; assertFalse(q.contains(makeElement(99))); assertFalse(q.remove(makeElement(99))); checkEmpty(q); for (int i = 1; i < size; i += 2) { for (int pass = 0; pass < 2; pass++) { assertEquals((pass == 0), q.contains(elts[i])); assertEquals((pass == 0), q.remove(elts[i])); assertFalse(q.contains(elts[i])); assertTrue(q.contains(elts[i - 1])); if (i < size - 1) assertTrue(q.contains(elts[i + 1])); assertTrue(q.contains(elts[0])); for (int i = size - 2; i >= 0; i -= 2) { assertTrue(q.contains(elts[i])); assertFalse(q.contains(elts[i + 1])); assertTrue(q.remove(elts[i])); assertFalse(q.contains(elts[i])); assertFalse(q.remove(elts[i + 1])); assertFalse(q.contains(elts[i + 1]));
@Override public boolean contains(Object o) { return queue.contains(o); }
/** * Returns <code>true</code> if a given job is waiting or running; * <code>false</code> if the job is finished or doesn't exist in the queue. * * @deprecated unused */ @Deprecated public boolean isJobActive(Job job) { synchronized (_jobLock) { if (_readyJobs.contains(job) || _timedJobs.contains(job)) return true; } for (JobQueueRunner runner: _queueRunners.values()) if (runner.getCurrentJob() == job) return true; return false; }
public void handle(MessageSender messageSender) { final Runnable runnable = new PushBackReconnectRunnable( messageSender, senders, pendingTasks, grpcRetryContext.getReconnectedSenders() ); synchronized (pendingTasks) { if (!pendingTasks.contains(runnable)) { pendingTasks.offer(runnable); } } }
if (this.removeConsumerProducer == null) { // dedicated consumer producers are not cached synchronized (this) { if (!this.cache.contains(this) && !this.cache.offer(this)) { if (unit == null) {
/** * Forces a validation of all idle connections if {@link PoolProperties#testWhileIdle} is set. */ public void testAllIdle() { try { if (idle.size()==0) return; Iterator<PooledConnection> unlocked = idle.iterator(); while (unlocked.hasNext()) { PooledConnection con = unlocked.next(); try { con.lock(); //the con been taken out, we can't clean it up if (busy.contains(con)) continue; if (!con.validate(PooledConnection.VALIDATE_IDLE)) { idle.remove(con); release(con); } } finally { con.unlock(); } } //while } catch (ConcurrentModificationException e) { log.debug("testAllIdle failed." ,e); } catch (Exception e) { log.warn("testAllIdle failed, it will be retried.",e); } }
con.lock(); if (busy.contains(con)) continue; long time = con.getTimestamp();
if (idle.contains(con)) continue; long time = con.getTimestamp();
assertTrue(locked.contains("done")); pool.shutdownNow();
if (_readyJobs.contains(job)) alreadyExists = true; numReady = _readyJobs.size();
/** {@inheritDoc} */ @Override public final ScheduledFuture<?> updateNode(int nodeId) { AdapterOperation op = new AdapterOperation(Integer.valueOf(nodeId), AdapterOperationType.UPDATE, createScheduleForNode(nodeId, AdapterOperationType.UPDATE)); synchronized (m_executorService) { if (!m_executorService.getQueue().contains(op)) { return op.schedule(m_executorService); } } return null; }