Refine search
@Override public List<SourceRecord> poll() throws InterruptedException { if (records.isEmpty()) { // block forever, as this thread will be interrupted if/when the task is stopped ... new CountDownLatch(1).await(); } if (running.get()) { // Still running, so process whatever is in the queue ... List<SourceRecord> results = new ArrayList<>(); int record = 0; while (record < recordsPerBatch && !records.isEmpty()) { results.add(records.poll()); } return results; } // No longer running ... return null; }
private <U> Collection<U> reap(Queue<TimedObject<U>> queue, long timeout) { List<U> toReap = new ArrayList<U>(); long now = System.currentTimeMillis(); long target = now - timeout; synchronized (_lock) { int excess = _poolSize - _minSize; for (TimedObject<U> p; ((p = queue.peek()) != null) && (p.getTime() < target) && (excess > 0); excess--) { toReap.add(queue.poll().get()); _totalTimedOut++; } } return toReap; }
public Queue<PipelineConfigQueueEntry> buildQueue() { Queue<PipelineConfigQueueEntry> configQueue = new LinkedList<>(); Queue<PipelineConfigDependencyEntry> tmp = new LinkedList<>(); tmp.add(new PipelineConfigDependencyEntry(this, new ArrayList<>())); while (true) { PipelineConfigDependencyEntry currentHead = tmp.poll(); if (currentHead == null) { break; } PipelineConfigDependencyGraph current = currentHead.getNode(); List<PipelineConfig> currentPath = currentHead.getPath(); currentPath.add(current.getCurrent()); configQueue.add(new PipelineConfigQueueEntry(current.getCurrent(), new ArrayList<>(currentPath))); for (PipelineConfigDependencyGraph upstream : current.getUpstreamDependencies()) { List<PipelineConfig> parentsPath = new ArrayList<>(currentPath); tmp.add(new PipelineConfigDependencyEntry(upstream, parentsPath)); } } return removeHead(configQueue); }
/** * delete all file * * @param directory */ public static void deleteAllFile(String directory) { List<File> fileList = new ArrayList<File>(); File directoryFile = new File(directory); Queue<File> queue = new ConcurrentLinkedQueue<File>(); queue.add(directoryFile); while (!queue.isEmpty()) { File file = queue.poll(); if (file.isDirectory()) { File[] fileArray = file.listFiles(); if (fileArray != null) { queue.addAll(Arrays.asList(fileArray)); } } fileList.add(file); } for (int i = fileList.size() - 1; i >= 0; i--) { fileList.get(i).delete(); } }
protected View findScrollableViewInternal(View content, boolean selfable) { View scrollableView = null; Queue<View> views = new LinkedList<>(Collections.singletonList(content)); while (!views.isEmpty() && scrollableView == null) { View view = views.poll(); if (view != null) { if ((selfable || view != content) && isContentView(view)) { scrollableView = view; } else if (view instanceof ViewGroup) { ViewGroup group = (ViewGroup) view; for (int j = 0; j < group.getChildCount(); j++) { views.add(group.getChildAt(j)); } } } } return scrollableView == null ? content : scrollableView; }
/** * Drains the recency queue, updating eviction metadata that the entries therein were read in * the specified relative order. This currently amounts to adding them to relevant eviction * lists (accounting for the fact that they could have been removed from the map since being * added to the recency queue). */ @GuardedBy("this") void drainRecencyQueue() { ReferenceEntry<K, V> e; while ((e = recencyQueue.poll()) != null) { // An entry may be in the recency queue despite it being removed from // the map . This can occur when the entry was concurrently read while a // writer is removing it from the segment or after a clear has removed // all of the segment's entries. if (accessQueue.contains(e)) { accessQueue.add(e); } } }
@Override protected void flushCache() throws SockJsTransportFailureException { while (!getMessageCache().isEmpty()) { String message = getMessageCache().poll(); SockJsMessageCodec messageCodec = getSockJsServiceConfig().getMessageCodec(); SockJsFrame frame = SockJsFrame.messageFrame(messageCodec, message); writeFrame(frame); this.byteCount += (frame.getContentBytes().length + 1); if (logger.isTraceEnabled()) { logger.trace(this.byteCount + " bytes written so far, " + getMessageCache().size() + " more messages not flushed"); } if (this.byteCount >= getSockJsServiceConfig().getStreamBytesLimit()) { logger.trace("Streamed bytes limit reached, recycling current request"); resetRequest(); this.byteCount = 0; break; } } scheduleHeartbeat(); }
/** * @throws Exception If failed. */ @Test public void testArrayDeque() throws Exception { Queue<Integer> queue = new ArrayDeque<>(); for (int i = 0; i < 100; i++) queue.add(i); Queue<Integer> newQueue = marshalUnmarshal(queue); assertEquals(queue.size(), newQueue.size()); Integer i; while ((i = newQueue.poll()) != null) assertEquals(queue.poll(), i); }
@Override public boolean next() throws SQLException { if (orderByValuesQueue.isEmpty()) { return false; } if (isFirstNext) { isFirstNext = false; return true; } OrderByValue firstOrderByValue = orderByValuesQueue.poll(); if (firstOrderByValue.next()) { orderByValuesQueue.offer(firstOrderByValue); } if (orderByValuesQueue.isEmpty()) { return false; } setCurrentQueryResult(orderByValuesQueue.peek().getQueryResult()); return true; } }
private static List<MessageHolder> createConsoleResult(SimpleEvaluationObject seo, Message message) { List<MessageHolder> result = new ArrayList<>(); while (!seo.getConsoleOutput().isEmpty()) { ConsoleOutput co = seo.getConsoleOutput().poll(); //FIFO : peek to see, poll -- removes the data result.add(new MessageHolder(SocketEnum.IOPUB_SOCKET, buildOutputMessage(message, co.getText(), co.isError()))); } return result; }
@Override public MessageConsumer<T> setMaxBufferedMessages(int maxBufferedMessages) { Arguments.require(maxBufferedMessages >= 0, "Max buffered messages cannot be negative"); List<Message<T>> discarded; Handler<Message<T>> discardHandler; synchronized (this) { this.maxBufferedMessages = maxBufferedMessages; int overflow = pending.size() - maxBufferedMessages; if (overflow <= 0) { return this; } discardHandler = this.discardHandler; if (discardHandler == null) { while (pending.size() > maxBufferedMessages) { pending.poll(); } return this; } discarded = new ArrayList<>(overflow); while (pending.size() > maxBufferedMessages) { discarded.add(pending.poll()); } } for (Message<T> msg : discarded) { discardHandler.handle(msg); } return this; }