Java Code Examples for com.google.common.collect.Queues#newArrayBlockingQueue()

SelectDispatcher(SelectConfig config) {
    super(config);

    m_config = config;

    CassandraSession session = new CassandraSessionImpl(
            config.getCassandraKeyspace(),
            config.getCassandraHost(),
            config.getCassandraPort(),
            config.getCassandraCompression(),
            config.getCassandraUsername(),
            config.getCassandraPassword(),
            config.getCassandraSsl());
    m_repository = new CassandraSampleRepository(
            session,
            Config.CASSANDRA_TTL,
            m_metricRegistry,
            new DefaultSampleProcessorService(1),
            new ContextConfigurations());

    m_queryQueue = Queues.newArrayBlockingQueue(config.getThreads() * 10);

}
 

public ChunkRenderDispatcherLitematica()
{
    int threadLimitMemory = Math.max(1, (int)((double)Runtime.getRuntime().maxMemory() * 0.15D) / 10485760);
    int threadLimitCPU = Math.max(1, MathHelper.clamp(Runtime.getRuntime().availableProcessors(), 1, threadLimitMemory / 5));
    this.countRenderBuilders = MathHelper.clamp(threadLimitCPU * 8, 1, threadLimitMemory);

    if (threadLimitCPU > 1)
    {
        Litematica.logger.info("Creating {} render threads", threadLimitCPU);

        for (int i = 0; i < threadLimitCPU; ++i)
        {
            ChunkRenderWorkerLitematica worker = new ChunkRenderWorkerLitematica(this);
            Thread thread = THREAD_FACTORY.newThread(worker);
            thread.start();
            this.listThreadedWorkers.add(worker);
            this.listWorkerThreads.add(thread);
        }
    }

    Litematica.logger.info("Using {} total BufferBuilder caches", this.countRenderBuilders + 1);

    this.queueFreeRenderBuilders = Queues.newArrayBlockingQueue(this.countRenderBuilders);

    for (int i = 0; i < this.countRenderBuilders; ++i)
    {
        this.queueFreeRenderBuilders.add(new BufferBuilderCache());
    }

    this.renderWorker = new ChunkRenderWorkerLitematica(this, new BufferBuilderCache());
}
 

public TessellatorCache(int capacity, Supplier<E> supplier) {
  cache = Queues.newArrayBlockingQueue(capacity);
  
  // fill the cache
  for (int i = 0; i < capacity; i++) {
    cache.add(supplier.get());
  }
  
  // copy list of the original tessellators to prevent others from being added
  originals = ImmutableList.copyOf(cache);
}
 

private BoundedBlockingRecordQueue(Builder<T> builder) {
  Preconditions.checkArgument(builder.capacity > 0, "Invalid queue capacity");
  Preconditions.checkArgument(builder.timeout > 0, "Invalid timeout time");

  this.capacity = builder.capacity;
  this.timeout = builder.timeout;
  this.timeoutTimeUnit = builder.timeoutTimeUnit;
  this.blockingQueue = Queues.newArrayBlockingQueue(builder.capacity);

  this.queueStats = builder.ifCollectStats ? Optional.of(new QueueStats()) : Optional.<QueueStats> absent();
}
 

private ArrayBlockingQueue<StratumMessage> makeSubscriptionQueue() {
    return Queues.newArrayBlockingQueue(SUBSCRIPTION_QUEUE_CAPACITY);
}
 

public ControllableCallable(Either<T, Exception> toReturn, String name) {
  this.queue = Queues.newArrayBlockingQueue(1);
  this.queue.add(true);
  this.toReturn = toReturn;
  this.name = name;
}
 

InsertDispatcher(InsertConfig config) throws InterruptedException {
    super(config);

    m_config = config;

    CassandraSession session = new CassandraSessionImpl(
            config.getCassandraKeyspace(),
            config.getCassandraHost(),
            config.getCassandraPort(),
            config.getCassandraCompression(),
            config.getCassandraUsername(),
            config.getCassandraPassword(),
            config.getCassandraSsl());

    ContextConfigurations contexts = new ContextConfigurations();
    Set<SampleProcessor> processors = Sets.newHashSet();

    if (m_config.isSearchEnabled()) {
        ResourceIdSplitter resourceIdSplitter = new EscapableResourceIdSplitter();
        GuavaResourceMetadataCache cache = new GuavaResourceMetadataCache(m_config.getNumResources(), m_metricRegistry);
        CassandraIndexingOptions indexingOptions = new CassandraIndexingOptions.Builder()
                .withHierarchicalIndexing(m_config.isHierarchicalIndexingEnabled())
                .withMaxBatchSize(m_config.getBatchSize()).build();
        CassandraIndexer cassandraIndexer = new CassandraIndexer(session, Config.CASSANDRA_TTL,
                cache, m_metricRegistry, indexingOptions, resourceIdSplitter, contexts);
        CassandraIndexerSampleProcessor indexerSampleProcessor = new CassandraIndexerSampleProcessor(cassandraIndexer);
        processors.add(indexerSampleProcessor);
    }

    SampleProcessorService sampleProcessorService = new DefaultSampleProcessorService(m_config.getThreads(), processors);

    m_repository = new CassandraSampleRepository(
            session,
            Config.CASSANDRA_TTL,
            m_metricRegistry,
            sampleProcessorService,
            contexts);

    m_samplesQueue = Queues.newArrayBlockingQueue(config.getThreads() * 10);

}
 

/**
 * Creates and registers a new {@link ArrayBlockingQueue} with given initial
 * capacity.
 *  
 * @param queueName
 * 			The name of the queue
 * @param capacity
 * 			The initial capacity of the queue
 * @return
 * 		the created and registered queue
 * 
 * @throws IllegalArgumentException if <code>queueName</code> is already registered.
 */
public BlockingQueue<CollectionDocument> registerQueue(String queueName, int capacity) {
	Preconditions.checkArgument(!registry.containsKey(queueName), "Queue %s already exists", queueName);
	ArrayBlockingQueue<CollectionDocument> q = Queues.newArrayBlockingQueue(capacity);
	registry.put(queueName, q);
	return q;
}
 

public ScannerSession(String tableName, Set<Authorizations> auths, ResourceQueue delegator, int maxResults, Query settings, SessionOptions options,
                Collection<Range> ranges) {
    
    Preconditions.checkNotNull(options);
    Preconditions.checkNotNull(delegator);
    
    this.options = options;
    
    // build a stack of ranges
    this.ranges = new ConcurrentLinkedQueue<>();
    
    this.tableName = tableName;
    this.auths = auths;
    
    if (null != ranges && !ranges.isEmpty()) {
        List<Range> rangeList = Lists.newArrayList(ranges);
        Collections.sort(rangeList);
        
        this.ranges.addAll(ranges);
        lastRange = Iterables.getLast(rangeList);
        
    }
    
    resultQueue = Queues.newArrayBlockingQueue(maxResults);
    
    sessionDelegator = delegator;
    
    currentEntry = null;
    
    this.maxResults = maxResults;
    
    this.settings = settings;
    
    if (this.settings != null) {
        this.uncaughtExceptionHandler = this.settings.getUncaughtExceptionHandler();
    }
    
    // ensure we have an exception handler
    if (this.uncaughtExceptionHandler == null) {
        this.uncaughtExceptionHandler = new QueryUncaughtExceptionHandler();
    }
    
    delegatedResourceInitializer = RunningResource.class;
    
}