@Inject public FileQueueProcessor( DataPointEventSerializer eventSerializer, BigArray bigArray, @Named(QUEUE_PROCESSOR) ExecutorService executor, @Named(BATCH_SIZE) int batchSize, @Named(MEMORY_QUEUE_SIZE) int memoryQueueSize, @Named(SECONDS_TILL_CHECKPOINT) int secondsTillCheckpoint, @Named(MINIMUM_BATCH_SIZE) int minimumBatchSize, @Named(MINIMUM_BATCH_WAIT) int minBatchWait) { super(executor, batchSize, minimumBatchSize, minBatchWait); m_bigArray = bigArray; m_memoryQueue = new CircularFifoQueue<>(memoryQueueSize); m_eventSerializer = eventSerializer; m_nextIndex = m_bigArray.getTailIndex(); m_secondsTillCheckpoint = secondsTillCheckpoint; m_shuttingDown = false; }
private void addNodeEvent(final NodeIdentifier nodeId, final Severity severity, final String message) { final NodeEvent event = new Event(nodeId.toString(), message, severity); final CircularFifoQueue<NodeEvent> eventQueue = nodeEvents.computeIfAbsent(nodeId, id -> new CircularFifoQueue<>()); synchronized (eventQueue) { eventQueue.add(event); } }
private void addPrivateMessageToList(final User user, final String message) { Collection<String> userMessages = privateMessages.get(user); if (userMessages == null) { userMessages = new CircularFifoQueue<>(MAX_MESSAGES); privateMessages.put(user, userMessages); } userMessages.add(message); final Integer userCount = privateMessageCount.get(user); if (userCount == null) { privateMessageCount.put(user, 1); } else { privateMessageCount.put(user, userCount + 1); } }
public MessageNotificationService(final Context context, final NotificationManager notificationManager, final AndroidSettings settings) { this.context = context; this.notificationManager = notificationManager; notificationHelper = new NotificationHelper(context, settings); messages = new CircularFifoQueue<>(MAX_MESSAGES); privateMessages = new HashMap<>(); privateMessageCount = new HashMap<>(); }
public DayRecord(final long timestamp, final int maxSize) { this.dayKey = getDayKey(timestamp); this.records = new CircularFifoQueue(maxSize); }
public DayRecord(final long timestamp, final int maxSize) { this.dayKey = getDayKey(timestamp); this.records = new CircularFifoQueue(maxSize); }
public MergedReadAhead(FacetedConfiguration facetedConfig, final Iterator<T> iter, Function<T,T> functionalMerge, List<Predicate<T>> filters) { this.facetedConfig = facetedConfig; this.iter = Iterators.transform(iter, functionalMerge); for (Predicate<T> predicate : filters) { this.iter = Iterators.filter(this.iter, predicate); } buf = QueueUtils.synchronizedQueue(new CircularFifoQueue(1)); startAndWait(); }
@Override public void logPublishing(String path, String user, String workspaceName, String subscriber, boolean unpublishing, boolean success) { if (unpublishing) { unpublishingRequests.incrementAndGet(); } else { publishingRequests.incrementAndGet(); } PublishingLogEntry entry = new PublishingLogEntry(unpublishing, success, path, subscriber, user, workspaceName, Calendar.getInstance().getTime(), null); this.publishingLog.add(entry); if (!this.publishingRequestsPerWorkspace.containsKey(workspaceName)) { this.publishingRequestsPerWorkspace.put(workspaceName, 1); } else { AtomicInteger count = new AtomicInteger(this.publishingRequestsPerWorkspace.get(workspaceName)); this.publishingRequestsPerWorkspace.put(workspaceName, count.incrementAndGet()); } if (!this.publishingRequestsMadeByUser.containsKey(user)) { Queue<PublishingLogEntry> buffer = Queues.synchronizedQueue(new CircularFifoQueue<>(100)); buffer.add(entry); this.publishingRequestsMadeByUser.put(user, buffer); } else { Queue<PublishingLogEntry> buffer = this.publishingRequestsMadeByUser.get(user); buffer.add(entry); } }
@SuppressWarnings("unchecked") public MemoryActivationStorage() { activations = new AtomicInteger(); deactivations = new AtomicInteger(); activationErrors = new AtomicInteger(); commitedTransactions = new AtomicInteger(); rollbackedTransactions = new AtomicInteger(); sizeOfActivatedContent = new AtomicLong(); activationTime = new AtomicLong(); lastRestart = Calendar.getInstance().getTime(); activationLog = Queues.synchronizedQueue(new CircularFifoQueue<>(500)); activationErrorLog = Queues.synchronizedQueue(new CircularFifoQueue<>(500)); activationsPerWorkspace = Collections.synchronizedMap(new LRUMap(500)); activationsMadeByUser = Collections.synchronizedMap(new LRUMap(500)); subscriberResponseTimes = Collections.synchronizedMap(new LRUMap(500)); }
@SuppressWarnings("unchecked") @Override public void logActivation(String path, String user, String workspaceName, String subscriber, boolean deactivation, boolean success) { if (deactivation) { deactivations.incrementAndGet(); } else { activations.incrementAndGet(); } ActivationLogEntry entry = new ActivationLogEntry(deactivation, success, path, subscriber, user, workspaceName, getCurrentDate()); this.activationLog.add(entry); if (!this.activationsPerWorkspace.containsKey(workspaceName)) { this.activationsPerWorkspace.put(workspaceName, 1); } else { AtomicInteger count = new AtomicInteger(this.activationsPerWorkspace.get(workspaceName)); this.activationsPerWorkspace.put(workspaceName, count.incrementAndGet()); } if (!this.activationsMadeByUser.containsKey(user)) { Queue<ActivationLogEntry> buffer = Queues.synchronizedQueue(new CircularFifoQueue<>(100)); buffer.add(entry); this.activationsMadeByUser.put(user, buffer); } else { Queue buffer = this.activationsMadeByUser.get(user); buffer.add(entry); } }
private String runSbt(final LineConsumer buildLogHandler, final Map<String, String> envVarsForApp, final List<String> arguments) { final CommandLine command = sbtCmd.commandLine(envVarsForApp); for (final String argument : arguments) { command.addArgument(argument); } buildLogHandler.consumeLine("Running sbt " + StringUtils.join(arguments, " ") + " with " + command); final CircularFifoQueue<String> latestBuildLog = new CircularFifoQueue<>(SBT_LINE_BUFFER); final LineConsumer capturingBuildLogHandler = line -> { buildLogHandler.consumeLine(line); latestBuildLog.add(line); }; ProcessStarter.run(capturingBuildLogHandler, envVarsForApp, command, projectRoot, MINUTES.toMillis(20)); for (final String line : latestBuildLog) { final Matcher matcher = ARTIFACT_PATH_REGEX.matcher(line); if (matcher.matches()) { return matcher.group(1); } } throw new RuntimeException("Artifact path not found within last " + SBT_LINE_BUFFER + " lines of build log"); } }
this.clock = clock; this.flushIntervalInMS = flushIntervalInMS; records = new CircularFifoQueue<>(maxSize); serviceStarted = false; this.logger = logger;
this.clock = clock; this.flushIntervalInMS = flushIntervalInMS; records = new CircularFifoQueue<>(maxSize); serviceStarted = false; this.logger = logger;
boolean useKeyCache = config.getBoolean("max one per host+status"); Queue<String> cache = new CircularFifoQueue<>(cache_size); HashSet<String> remainingHosts = new HashSet<>(); cache = new CircularFifoQueue<>(max(min(remainingHosts.size()-1, thread_count), 1));
/** * initialize my canInfo * * @param canInfo */ public void init(CANInfo canInfo) { this.canInfo = canInfo; for (int i = 0; i < canInfo.getMaxIndex(); i++) { getValueItems().add(new ValueItem<ValueType>()); } if (canInfo.getHistoryValuesPerMinute() > 0) this.historyMSecs = 60000 / canInfo.getHistoryValuesPerMinute(); else this.historyMSecs = Long.MAX_VALUE; // create a history buffer for MAX_HISTORY_MINUTES setHistory(new CircularFifoQueue<ValueItem<ValueType>>( canInfo.getHistoryValuesPerMinute() * MAX_HISTORY_MINUTES + 1)); }
System.out.println("ra: window: " + window); CircularFifoQueue<Measurement> slidingWindow = new CircularFifoQueue(window);
recentParams = new CircularFifoQueue<>(bucketSize *3); Utilities.out("Selected bucket size: "+ bucketSize + " for "+ targetURL);