Java Queues.newArrayBlockingQueue方法代码示例

import com.google.common.collect.Queues; //导入方法依赖的package包/类
public FileReaderService(PathSet pathSet,
                         Charset charset,
                         FileInput.InitialReadPosition initialReadPosition,
                         FileInput input,
                         MessageBuilder messageBuilder,
                         ContentSplitter contentSplitter,
                         Buffer buffer,
                         int readerBufferSize,
                         long readerInterval,
                         FileObserver fileObserver) {
    this.pathSet = pathSet;
    this.initialReadPosition = initialReadPosition;
    this.input = input;
    this.messageBuilder = messageBuilder;
    this.contentSplitter = contentSplitter;
    this.buffer = buffer;
    this.charset = charset;
    this.readerBufferSize = readerBufferSize;
    this.readerInterval = readerInterval;
    this.fileObserver = fileObserver;
    chunkQueue = Queues.newArrayBlockingQueue(2);
}
 

import com.google.common.collect.Queues; //导入方法依赖的package包/类
private NutchServer() {
  configManager = new ConfManagerImpl();
  BlockingQueue<Runnable> runnables = Queues.newArrayBlockingQueue(JOB_CAPACITY);
  NutchServerPoolExecutor executor = new NutchServerPoolExecutor(10, JOB_CAPACITY, 1, TimeUnit.HOURS, runnables);
  jobManager = new JobManagerImpl(new JobFactory(), configManager, executor);
  fetchNodeDb = FetchNodeDb.getInstance();

  sf = new JAXRSServerFactoryBean();
  BindingFactoryManager manager = sf.getBus().getExtension(BindingFactoryManager.class);
  JAXRSBindingFactory factory = new JAXRSBindingFactory();
  factory.setBus(sf.getBus());
  manager.registerBindingFactory(JAXRSBindingFactory.JAXRS_BINDING_ID, factory);
  sf.setResourceClasses(getClasses());
  sf.setResourceProviders(getResourceProviders());
  sf.setProvider(new JacksonJaxbJsonProvider());

}
 

import com.google.common.collect.Queues; //导入方法依赖的package包/类
protected ConsumerBase(PulsarClientImpl client, String topic, String subscription, ConsumerConfiguration conf,
        int receiverQueueSize, ExecutorService listenerExecutor, CompletableFuture<Consumer> subscribeFuture) {
    super(client, topic, new Backoff(100, TimeUnit.MILLISECONDS, 60, TimeUnit.SECONDS, 0 , TimeUnit.MILLISECONDS));
    this.maxReceiverQueueSize = receiverQueueSize;
    this.subscription = subscription;
    this.conf = conf;
    this.consumerName = conf.getConsumerName() == null ? ConsumerName.generateRandomName() : conf.getConsumerName();
    this.subscribeFuture = subscribeFuture;
    this.listener = conf.getMessageListener();
    if (receiverQueueSize <= 1) {
        this.incomingMessages = Queues.newArrayBlockingQueue(1);
    } else {
        this.incomingMessages = new GrowableArrayBlockingQueue<>();
    }

    this.listenerExecutor = listenerExecutor;
    this.pendingReceives = Queues.newConcurrentLinkedQueue();
}
 

import com.google.common.collect.Queues; //导入方法依赖的package包/类
@Test
public void log_errors() {
    final CommandEnvelope commandEnvelope = givenCommandEnvelope();

    // Since we're in the tests mode `Environment` returns `SubstituteLogger` instance.
    final SubstituteLogger log = (SubstituteLogger) handler.log();

    // Restrict the queue size only to the number of calls we want to make.
    final Queue<SubstituteLoggingEvent> queue = Queues.newArrayBlockingQueue(1);
    log.setDelegate(new EventRecodingLogger(log, queue));

    SubstituteLoggingEvent loggingEvent;

    final RuntimeException exception = new RuntimeException("log_errors");
    handler.onError(commandEnvelope, exception);

    loggingEvent = queue.poll();

    assertEquals(Level.ERROR, loggingEvent.getLevel());
    assertEquals(commandEnvelope, handler.getLastErrorEnvelope());
    assertEquals(exception, handler.getLastException());
}
 

import com.google.common.collect.Queues; //导入方法依赖的package包/类
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,
            new MetricRegistry(),
            new DefaultSampleProcessorService(1),
            new ContextConfigurations());

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

}
 

import com.google.common.collect.Queues; //导入方法依赖的package包/类
@Test
public void readPositionEnd() throws IOException, InterruptedException {
    final Utils.LogFile logFile = new Utils.LogFile(100 * 1024, 400, 100);
    logFile.close();
    final ArrayBlockingQueue<FileChunk> chunkQueue = Queues.newArrayBlockingQueue(1);
    final AsynchronousFileChannel channel = AsynchronousFileChannel.open(logFile.getPath(), StandardOpenOption.READ);
    final CountingAsyncFileChannel spy = new CountingAsyncFileChannel(channel);

    final ChunkReader chunkReader = new ChunkReader(mock(FileInput.class), logFile.getPath(), spy, chunkQueue, 10 * 1024,
            FileInput.InitialReadPosition.END, null);

    final ScheduledExecutorService chunkReaderExecutor = Executors.newSingleThreadScheduledExecutor(
            new ThreadFactoryBuilder()
                    .setDaemon(false)
                    .setNameFormat("file-chunk-reader-%d")
                    .setUncaughtExceptionHandler(this)
                    .build()
    );

    final Thread consumer = new Thread() {
        @Override
        public void run() {
            try {
                final FileChunk chunk = chunkQueue.poll(2, TimeUnit.SECONDS);
                assertNull("Reading from the end of the file must not produce a chunk for a non-changing file.", chunk);
            } catch (InterruptedException ignore) {
            }
        }
    };
    consumer.start();
    chunkReaderExecutor.scheduleAtFixedRate(chunkReader, 0, 250, TimeUnit.MILLISECONDS);
    consumer.join();

    // we can process one chunk at a time, so one read is queued, the second is buffered
    assertEquals("The e should be empty", 1, chunkQueue.remainingCapacity());
}
 

import com.google.common.collect.Queues; //导入方法依赖的package包/类
/**
 * 创建队列
 */
@Test
public void testCreateQueue() {
    List<String> strList = Lists.newArrayListWithExpectedSize(128);

    // 创建ArrayBlockingQueue
    ArrayBlockingQueue<String> blockingQueue = Queues.newArrayBlockingQueue(128);

    // 创建LinkedBlockingQueue
    LinkedBlockingQueue<String> linkedBlockingQueue1 = Queues.newLinkedBlockingQueue();
    LinkedBlockingQueue<String> linkedBlockingQueue2 = Queues.newLinkedBlockingQueue(128);
    LinkedBlockingQueue<String> linkedBlockingQueue3 = Queues.newLinkedBlockingQueue(strList);

    // 创建LinkedBlockingDeque
    LinkedBlockingDeque<String> blockingDeque1 = Queues.newLinkedBlockingDeque();
    LinkedBlockingDeque<String> blockingDeque2 = Queues.newLinkedBlockingDeque(128);
    LinkedBlockingDeque<String> blockingDeque3 = Queues.newLinkedBlockingDeque(strList);

    // 创建ArrayDeque
    ArrayDeque<String> arrayDeque1 = Queues.newArrayDeque();
    ArrayDeque<String> arrayDeque2 = Queues.newArrayDeque(strList);

    // 创建ConcurrentLinkedQueue
    ConcurrentLinkedQueue<String> concurrentLinkedQueue1 = Queues.newConcurrentLinkedQueue();
    ConcurrentLinkedQueue<String> concurrentLinkedQueue2 = Queues.newConcurrentLinkedQueue(strList);

    // 创建PriorityBlockingQueue
    PriorityBlockingQueue<String> priorityBlockingQueue1 = Queues.newPriorityBlockingQueue();
    PriorityBlockingQueue<String> priorityBlockingQueue2 = Queues.newPriorityBlockingQueue(strList);

    // 创建PriorityQueue
    PriorityQueue<Comparable> priorityQueue1 = Queues.newPriorityQueue();
    PriorityQueue<Comparable> priorityQueue2 = Queues.newPriorityQueue(strList);

    // 创建SynchronousQueue
    SynchronousQueue<String> synchronousQueue = Queues.newSynchronousQueue();
}
 

import com.google.common.collect.Queues; //导入方法依赖的package包/类
public ChunkRenderDispatcher(int countRenderBuilders)
{
    int i = Math.max(1, (int)((double)Runtime.getRuntime().maxMemory() * 0.3D) / 10485760);
    int j = Math.max(1, MathHelper.clamp_int(Runtime.getRuntime().availableProcessors(), 1, i / 5));
    if(countRenderBuilders < 0) countRenderBuilders = MathHelper.clamp_int(j * 10, 1, i);
    this.countRenderBuilders = countRenderBuilders;

    if (j > 1)
    {
        for (int k = 0; k < j; ++k)
        {
            ChunkRenderWorker chunkrenderworker = new ChunkRenderWorker(this);
            Thread thread = THREAD_FACTORY.newThread(chunkrenderworker);
            thread.start();
            this.listThreadedWorkers.add(chunkrenderworker);
            this.listWorkerThreads.add(thread);
        }
    }

    this.queueFreeRenderBuilders = Queues.<RegionRenderCacheBuilder>newArrayBlockingQueue(this.countRenderBuilders);

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

    this.renderWorker = new ChunkRenderWorker(this, new RegionRenderCacheBuilder());
}
 

import com.google.common.collect.Queues; //导入方法依赖的package包/类
private void assertAtLevel(Level level) {
    final LoggingObserver<Object> observer = getObserver(level);

    assertNotNull(observer);

    // Since we're in the tests mode `Environment` returns `SubstituteLogger` instance.
    final SubstituteLogger log = (SubstituteLogger) observer.log();

    // Restrict the queue size only to the number of calls we want to make.
    final Queue<SubstituteLoggingEvent> queue = Queues.newArrayBlockingQueue(3);
    log.setDelegate(new EventRecodingLogger(log, queue));

    SubstituteLoggingEvent loggingEvent;

    final String value = newUuid();
    observer.onNext(value);
    loggingEvent = queue.poll();
    assertNotNull(loggingEvent);
    assertLogLevel(loggingEvent, level);
    assertContains(loggingEvent, value);
    assertContains(loggingEvent, "onNext");

    final Timestamp currentTime = Time.getCurrentTime();
    final String timeStr = Timestamps.toString(currentTime);
    observer.onNext(currentTime);
    loggingEvent = queue.poll();
    assertNotNull(loggingEvent);
    assertLogLevel(loggingEvent, level);
    assertContains(loggingEvent, timeStr);

    observer.onCompleted();
    loggingEvent = queue.poll();
    assertNotNull(loggingEvent);
    assertLogLevel(loggingEvent, level);
    assertContains(loggingEvent, "onCompleted");
}
 

import com.google.common.collect.Queues; //导入方法依赖的package包/类
public EmbeddedJetty(boolean isDebugMode) {

		ArrayBlockingQueue<Runnable> queue = Queues.newArrayBlockingQueue(this.capability);
		pool = new QueuedThreadPool(this.maxThreads, this.minThreads, this.idleTimeout, queue);
		{
			pool.setName("jetty");
			pool.setDetailedDump(isDebugMode);
			pool.setStopTimeout(this.stopTimeout);
		}

		this.server = new Server(pool);
		this.server.setStopAtShutdown(true);

		// set default error page to empty
		if (false == isDebugMode) {
			this.server.addBean(emtpyErrorPage);
			emtpyErrorPage.setServer(this.server);

			this.server.setDumpAfterStart(false);
			this.server.setDumpBeforeStop(false);
		}

		this.httpConfig = new HttpConfiguration();
		{
			this.httpConfig.setSendServerVersion(false);
			this.httpConfig.setSendXPoweredBy(false);
			this.httpConfig.setSendDateHeader(true);
		}

		this.handlers = new HandlerCollection();
		this.server.setHandler(handlers);
	}
 

import com.google.common.collect.Queues; //导入方法依赖的package包/类
/**
 * 设置配置属性
 * 编译时接口
 * 各种配置属性的缺失，可以在该阶段快速发现
 *
 */
@Override
public void setConfig(StreamingConfig conf) throws StreamingException
{
    queue = Queues.newArrayBlockingQueue(DEFAULT_QUEUE_LENGTH);
    listenerPort = conf.getIntValue(StreamingConfig.OPERATOR_TCPSERVER_PORT);
    fixedLength = conf.getIntValue(StreamingConfig.OPERATOR_TCPSERVER_FIXEDLENGTH);
    this.config = conf;
}
 

import com.google.common.collect.Queues; //导入方法依赖的package包/类
public Service(String name, String logfile, Integer capacity, Boolean watchBufferEnabled) {
    this.setName(name);
    this.logfile = logfile;
    this.capacity = capacity;
    this.watchBufferEnabled = watchBufferEnabled;

    this.exitFlag = true;
    this.queue = Queues.newArrayBlockingQueue(capacity);
}
 

import com.google.common.collect.Queues; //导入方法依赖的package包/类
@Test
public void testCommandHistory() throws InterruptedException
{
    BlockingQueue<MockClient.InvokeDetails> results = Queues.newArrayBlockingQueue(1);
    MockClient client = new MockClient(results);
    client.command().history().invoke();

    MockClient.InvokeDetails details = results.poll(1, TimeUnit.SECONDS);
    Assert.assertNotNull(details);
    Assert.assertEquals(details.getAdditionalPaths(), new String[]{"commands"});
    Assert.assertEquals(details.getResponseType(), Commands.class);
    Assert.assertNull(details.getForPage());
}
 

import com.google.common.collect.Queues; //导入方法依赖的package包/类
@Test
public void testCommandHistoryWithPaging() throws InterruptedException
{
    BlockingQueue<MockClient.InvokeDetails> results = Queues.newArrayBlockingQueue(1);
    MockClient client = new MockClient(results);
    client.command().history().forPage(10, 20).invoke();

    MockClient.InvokeDetails details = results.poll(1, TimeUnit.SECONDS);
    Assert.assertNotNull(details);
    Assert.assertEquals(details.getAdditionalPaths(), new String[]{"commands"});
    Assert.assertEquals(details.getResponseType(), Commands.class);
    Assert.assertEquals(details.getForPage(), new ForPage(10, 20));
}
 

import com.google.common.collect.Queues; //导入方法依赖的package包/类
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();
}