TaskQueue (Apache Tomcat 9.0.37 API Documentation)

org.apache.tomcat.util.threads

## Class TaskQueue

- java.lang.Object
- - java.util.AbstractCollection<E>
  - - java.util.AbstractQueue<E>
    - - java.util.concurrent.LinkedBlockingQueue<Runnable>
      - - org.apache.tomcat.util.threads.TaskQueue

- All Implemented Interfaces:
    Serializable, Iterable<Runnable>, Collection<Runnable>, BlockingQueue<Runnable>, Queue<Runnable>

      public class TaskQueue
      extends LinkedBlockingQueue<Runnable>

  As task queue specifically designed to run with a thread pool executor. The task queue is optimised to properly utilize threads within a thread pool executor. If you use a normal queue, the executor will spawn threads when there are idle threads and you wont be able to force items onto the queue itself.
  See Also:
    Serialized Form

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected static StringManager` | `sm`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `TaskQueue()`
    `TaskQueue(Collection<? extends Runnable> c)`
    `TaskQueue(int capacity)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `force(Runnable o)`
    `boolean` | `force(Runnable o, long timeout, TimeUnit unit)`
    `boolean` | `offer(Runnable o)`
    `Runnable` | `poll(long timeout, TimeUnit unit)`
    `int` | `remainingCapacity()`
    `void` | `setForcedRemainingCapacity(Integer forcedRemainingCapacity)`
    `void` | `setParent(ThreadPoolExecutor tp)`
    `Runnable` | `take()`

    - ### Methods inherited from class java.util.concurrent.LinkedBlockingQueue

      `clear, contains, drainTo, drainTo, iterator, offer, peek, poll, put, remove, size, spliterator, toArray, toArray, toString`

    - ### Methods inherited from class java.util.AbstractQueue

      `add, addAll, element, remove`

    - ### Methods inherited from class java.util.AbstractCollection

      `containsAll, isEmpty, removeAll, retainAll`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface java.util.concurrent.BlockingQueue

      `add`

    - ### Methods inherited from interface java.util.Queue

      `element, remove`

    - ### Methods inherited from interface java.util.Collection

      `addAll, containsAll, equals, hashCode, isEmpty, parallelStream, removeAll, removeIf, retainAll, stream`

    - ### Methods inherited from interface java.lang.Iterable

      `forEach`

- - ### Field Detail

    - #### sm

          protected static final StringManager sm

  - ### Constructor Detail

    - #### TaskQueue

          public TaskQueue()

    - #### TaskQueue

          public TaskQueue(int capacity)

    - #### TaskQueue

          public TaskQueue(Collection<? extends Runnable> c)

  - ### Method Detail

    - #### setParent

          public void setParent(ThreadPoolExecutor tp)

    - #### force

          public boolean force(Runnable o)

    - #### force

          public boolean force(Runnable o,
                               long timeout,
                               TimeUnit unit)
                        throws InterruptedException

      Throws:
        `InterruptedException`

    - #### offer

          public boolean offer(Runnable o)

      Specified by:
        `offer` in interface `BlockingQueue<Runnable>`
      Specified by:
        `offer` in interface `Queue<Runnable>`
      Overrides:
        `offer` in class `LinkedBlockingQueue<Runnable>`

    - #### poll

          public Runnable poll(long timeout,
                               TimeUnit unit)
                        throws InterruptedException

      Specified by:
        `poll` in interface `BlockingQueue<Runnable>`
      Overrides:
        `poll` in class `LinkedBlockingQueue<Runnable>`
      Throws:
        `InterruptedException`

    - #### take

          public Runnable take()
                        throws InterruptedException

      Specified by:
        `take` in interface `BlockingQueue<Runnable>`
      Overrides:
        `take` in class `LinkedBlockingQueue<Runnable>`
      Throws:
        `InterruptedException`

    - #### remainingCapacity

          public int remainingCapacity()

      Specified by:
        `remainingCapacity` in interface `BlockingQueue<Runnable>`
      Overrides:
        `remainingCapacity` in class `LinkedBlockingQueue<Runnable>`

    - #### setForcedRemainingCapacity

          public void setForcedRemainingCapacity(Integer forcedRemainingCapacity)

Copyright © 2000-2020 Apache Software Foundation. All Rights Reserved.