Example usage for com.google.common.collect Queues newLinkedBlockingDeque

Introduction

In this page you can find the example usage for com.google.common.collect Queues newLinkedBlockingDeque.

Prototype

public static <E> LinkedBlockingDeque<E> newLinkedBlockingDeque() 

Source Link

Document

Creates an empty LinkedBlockingDeque with a capacity of Integer#MAX_VALUE .

Usage

From source file:org.terasology.world.chunks.store.ChunkStoreGZip.java

public void setup() {
    modifiedChunks = Maps.newConcurrentMap();
    compressionQueue = Queues.newLinkedBlockingDeque();
    setupThreads();
}

---

From source file:com.b2international.snowowl.core.validation.ValidateRequest.java

private ValidationResult doValidate(BranchContext context, Writer index) throws IOException {
    final String branchPath = context.branchPath();

    ValidationRuleSearchRequestBuilder req = ValidationRequests.rules().prepareSearch();

    if (!CompareUtils.isEmpty(ruleIds)) {
        req.filterByIds(ruleIds);/*from  w w  w  .  j  a v  a 2  s.  co m*/
    }

    final ValidationRules rules = req.all().build().execute(context);

    final ValidationThreadPool pool = context.service(ValidationThreadPool.class);
    final BlockingQueue<IssuesToPersist> issuesToPersistQueue = Queues.newLinkedBlockingDeque();
    final List<Promise<Object>> validationPromises = Lists.newArrayList();
    // evaluate selected rules
    for (ValidationRule rule : rules) {
        checkArgument(rule.getCheckType() != null, "CheckType is missing for rule " + rule.getId());
        final ValidationRuleEvaluator evaluator = ValidationRuleEvaluator.Registry.get(rule.getType());
        if (evaluator != null) {
            validationPromises.add(pool.submit(rule.getCheckType(), () -> {
                Stopwatch w = Stopwatch.createStarted();

                try {
                    LOG.info("Executing rule '{}'...", rule.getId());
                    final List<ComponentIdentifier> componentIdentifiers = evaluator.eval(context, rule,
                            ruleParameters);
                    issuesToPersistQueue.offer(new IssuesToPersist(rule.getId(), componentIdentifiers));
                    LOG.info("Execution of rule '{}' successfully completed in '{}'.", rule.getId(), w);
                    // TODO report successfully executed validation rule
                } catch (Exception e) {
                    // TODO report failed validation rule
                    LOG.info("Execution of rule '{}' failed after '{}'.", rule.getId(), w, e);
                }
            }));
        }
    }

    final Set<String> ruleIds = rules.stream().map(ValidationRule::getId).collect(Collectors.toSet());
    final Multimap<String, ComponentIdentifier> whiteListedEntries = fetchWhiteListEntries(context, ruleIds);

    final Promise<List<Object>> promise = Promise.all(validationPromises);

    while (!promise.isDone() || !issuesToPersistQueue.isEmpty()) {
        if (!issuesToPersistQueue.isEmpty()) {
            final Collection<IssuesToPersist> issuesToPersist = newArrayList();
            issuesToPersistQueue.drainTo(issuesToPersist);
            if (!issuesToPersist.isEmpty()) {
                final List<String> rulesToPersist = issuesToPersist.stream().map(itp -> itp.ruleId)
                        .collect(Collectors.toList());
                LOG.info("Persisting issues generated by rules '{}'...", rulesToPersist);
                // persist new issues generated by rules so far, extending them using the Issue Extension API
                int persistedIssues = 0;

                final Multimap<String, ValidationIssue> issuesToExtendWithDetailsByToolingId = HashMultimap
                        .create();
                for (IssuesToPersist ruleIssues : Iterables.consumingIterable(issuesToPersist)) {
                    final String ruleId = ruleIssues.ruleId;
                    final List<ValidationIssue> existingRuleIssues = ValidationRequests.issues().prepareSearch()
                            .all().filterByBranchPath(branchPath).filterByRule(ruleId).build().execute(context)
                            .getItems();

                    final Set<String> issueIdsToDelete = Sets.newHashSet();

                    final Map<ComponentIdentifier, ValidationIssue> existingIsssuesByComponentIdentifier = new HashMap<>();

                    for (ValidationIssue issue : existingRuleIssues) {
                        if (existingIsssuesByComponentIdentifier.containsKey(issue.getAffectedComponent())) {
                            issueIdsToDelete.add(issue.getId());
                        } else {
                            existingIsssuesByComponentIdentifier.put(issue.getAffectedComponent(), issue);
                        }
                    }

                    // remove all processed whitelist entries 
                    final Collection<ComponentIdentifier> ruleWhiteListEntries = whiteListedEntries
                            .removeAll(ruleId);
                    final String toolingId = rules.stream().filter(rule -> ruleId.equals(rule.getId()))
                            .findFirst().get().getToolingId();
                    for (ComponentIdentifier componentIdentifier : ruleIssues.affectedComponentIds) {

                        if (!existingIsssuesByComponentIdentifier.containsKey(componentIdentifier)) {
                            final ValidationIssue validationIssue = new ValidationIssue(
                                    UUID.randomUUID().toString(), ruleId, branchPath, componentIdentifier,
                                    ruleWhiteListEntries.contains(componentIdentifier));

                            issuesToExtendWithDetailsByToolingId.put(toolingId, validationIssue);
                            persistedIssues++;
                        } else {
                            final ValidationIssue issueToCopy = existingIsssuesByComponentIdentifier
                                    .get(componentIdentifier);

                            final ValidationIssue validationIssue = new ValidationIssue(issueToCopy.getId(),
                                    issueToCopy.getRuleId(), issueToCopy.getBranchPath(),
                                    issueToCopy.getAffectedComponent(),
                                    ruleWhiteListEntries.contains(issueToCopy.getAffectedComponent()));
                            validationIssue.setDetails(Maps.newHashMap());

                            issuesToExtendWithDetailsByToolingId.put(toolingId, validationIssue);
                            persistedIssues++;
                            existingIsssuesByComponentIdentifier.remove(componentIdentifier);
                        }
                    }

                    existingRuleIssues.stream()
                            .filter(issue -> existingIsssuesByComponentIdentifier
                                    .containsKey(issue.getAffectedComponent()))
                            .forEach(issue -> issueIdsToDelete.add(issue.getId()));

                    if (!issueIdsToDelete.isEmpty()) {
                        index.removeAll(Collections.singletonMap(ValidationIssue.class, issueIdsToDelete));
                    }

                }

                for (String toolingId : issuesToExtendWithDetailsByToolingId.keySet()) {
                    final ValidationIssueDetailExtension extensions = ValidationIssueDetailExtensionProvider.INSTANCE
                            .getExtensions(toolingId);
                    final Collection<ValidationIssue> issues = issuesToExtendWithDetailsByToolingId
                            .removeAll(toolingId);
                    extensions.extendIssues(context, issues);
                    for (ValidationIssue issue : issues) {
                        index.put(issue.getId(), issue);
                    }
                }
                index.commit();
                LOG.info("Persisted '{}' issues generated by rules '{}'.", persistedIssues, rulesToPersist);
            }
        }

        try {
            Thread.sleep(1000L);
        } catch (InterruptedException e) {
            throw new SnowowlRuntimeException(e);
        }
    }

    // TODO return ValidationResult object with status and new issue IDs as set
    return new ValidationResult(context.id(), context.branchPath());
}

---

From source file:com.facebook.watchman.WatchmanConnection.java

public WatchmanConnection(Supplier<Map<String, Object>> inputStream, OutputStream outputStream,
        Optional<Collection<String>> unilateralLabels, Optional<Callback> unilateralCallback,
        Optional<WatchmanCommandListener> commandListener, Optional<Socket> optionalSocket) {
    this.inputMessageSupplier = inputStream;
    this.outputStream = outputStream;
    this.unilateralLabels = unilateralLabels;
    this.unilateralCallback = unilateralCallback;
    this.socket = optionalSocket;
    this.processing = new AtomicBoolean(true);
    this.outgoingMessageExecutor = MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor(
            new ThreadFactoryBuilder().setNameFormat("[watchman] Outgoing Message Executor").build()));
    this.commandQueue = Queues.newLinkedBlockingDeque();
    this.bserSerializer = new BserSerializer();
    this.commandListener = commandListener;
    this.incomingMessageExecutor = Executors.newSingleThreadExecutor(
            new ThreadFactoryBuilder().setNameFormat("[watchman] Incoming Message Executor").build());
}

---