FancyBlockingQueue (deeplearning4j-nn 1.0.0-beta API)

java.lang.Object
- org.deeplearning4j.optimize.solvers.accumulation.FancyBlockingQueue<E>

All Implemented Interfaces:

Iterable<E>, Collection<E>, BlockingQueue<E>, Queue<E>, Registerable
```
public class FancyBlockingQueue<E>
extends Object
implements BlockingQueue<E>, Registerable
```
This BlockingQueue implementation is suited only for symmetric gradients updates, and should NOT be used anywhere else. Basic idea: all worker threads requesting via poll()/take() method will be advancing only once all consumers get the same element from Queue. So, multiple consumers are guaranteed to be consuming the same elements in the same order served by this queue.

Author:

[email protected]

Field Summary

Fields
Modifier and Type	Field and Description
`protected BlockingQueue<E>`	`backingQueue`
`protected AtomicInteger`	`barrier`
`protected AtomicBoolean`	`bypassMode`
`protected int`	`consumers`
`protected AtomicInteger`	`currentConsumers`
`protected ThreadLocal<AtomicLong>`	`currentStep`
`protected boolean`	`isDebug`
`protected AtomicBoolean`	`isDone`
`protected AtomicBoolean`	`isFirst`
`protected ReentrantReadWriteLock`	`lock`
`protected AtomicInteger`	`numElementsDrained`
`protected AtomicInteger`	`numElementsReady`
`protected AtomicInteger`	`secondary`
`protected AtomicInteger`	`state`
`protected AtomicLong`	`step`

Constructor Summary

Constructors
Constructor and Description

FancyBlockingQueue(BlockingQueue<E> queue)

FancyBlockingQueue(BlockingQueue<E> queue, int consumers)

Constructors
Constructor and Description
`FancyBlockingQueue(BlockingQueue<E> queue)`
`FancyBlockingQueue(BlockingQueue<E> queue, int consumers)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`add(E e)`
`boolean`	`addAll(Collection<? extends E> c)`
`void`	`clear()`
`boolean`	`contains(Object o)`
`boolean`	`containsAll(Collection<?> c)`
`int`	`drainTo(Collection<? super E> c)`
`int`	`drainTo(Collection<? super E> c, int maxElements)`
`E`	`element()`
`void`	`fallbackToSingleConsumerMode(boolean reallyFallback)` This method enables/disables bypass mode
`boolean`	`isEmpty()`
`Iterator<E>`	`iterator()`
`boolean`	`offer(E e)`
`boolean`	`offer(E e, long timeout, TimeUnit unit)`
`E`	`peek()`
`E`	`poll()`
`E`	`poll(long timeout, TimeUnit unit)`
`void`	`put(E e)`
`void`	`registerConsumers(int consumers)` This method notifies producer about number of consumers for the current consumption cycle
`int`	`remainingCapacity()`
`E`	`remove()`
`boolean`	`remove(Object o)`
`boolean`	`removeAll(Collection<?> c)`
`boolean`	`retainAll(Collection<?> c)`
`int`	`size()`
`protected void`	`synchronize(int consumers)`
`E`	`take()`
`Object[]`	`toArray()`
`<T> T[]`	`toArray(T[] a)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.util.Collection
equals, hashCode, parallelStream, removeIf, spliterator, stream

Methods inherited from interface java.lang.Iterable
forEach

- Field Detail
  - backingQueue
```
protected BlockingQueue<E> backingQueue
```
  - consumers
```
protected volatile int consumers
```
  - currentStep
```
protected ThreadLocal<AtomicLong> currentStep
```
  - step
```
protected final AtomicLong step
```
  - state
```
protected final AtomicInteger state
```
  - currentConsumers
```
protected final AtomicInteger currentConsumers
```
  - isFirst
```
protected AtomicBoolean isFirst
```
  - isDone
```
protected AtomicBoolean isDone
```
  - barrier
```
protected AtomicInteger barrier
```
  - secondary
```
protected AtomicInteger secondary
```
  - numElementsReady
```
protected AtomicInteger numElementsReady
```
  - numElementsDrained
```
protected AtomicInteger numElementsDrained
```
  - bypassMode
```
protected AtomicBoolean bypassMode
```
  - isDebug
```
protected boolean isDebug
```
  - lock
```
protected ReentrantReadWriteLock lock
```
- Constructor Detail
  - FancyBlockingQueue
```
public FancyBlockingQueue(@NonNull
                          BlockingQueue<E> queue)
```
  - FancyBlockingQueue
```
public FancyBlockingQueue(@NonNull
                          BlockingQueue<E> queue,
                          int consumers)
```
- Method Detail
  - add
```
public boolean add(E e)
```
    Specified by:
    
    add in interface Collection<E>
    
    Specified by:
    
    add in interface BlockingQueue<E>
    
    Specified by:
    
    add in interface Queue<E>
  - offer
```
public boolean offer(E e)
```
    Specified by:
    
    offer in interface BlockingQueue<E>
    
    Specified by:
    
    offer in interface Queue<E>
  - remove
```
public E remove()
```
    Specified by:
    
    remove in interface Queue<E>
  - fallbackToSingleConsumerMode
```
public void fallbackToSingleConsumerMode(boolean reallyFallback)
```
    Description copied from interface: Registerable
    
    This method enables/disables bypass mode
    
    Specified by:
    
    fallbackToSingleConsumerMode in interface Registerable
  - registerConsumers
```
public void registerConsumers(int consumers)
```
    Description copied from interface: Registerable
    
    This method notifies producer about number of consumers for the current consumption cycle
    
    Specified by:
    
    registerConsumers in interface Registerable
  - put
```
public void put(E e)
         throws InterruptedException
```
    Specified by:
    
    put in interface BlockingQueue<E>
    
    Throws:
    
    InterruptedException
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface Collection<E>
  - synchronize
```
protected void synchronize(int consumers)
```
  - poll
```
public E poll()
```
    Specified by:
    
    poll in interface Queue<E>
  - element
```
public E element()
```
    Specified by:
    
    element in interface Queue<E>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Collection<E>
  - size
```
public int size()
```
    Specified by:
    
    size in interface Collection<E>
  - peek
```
public E peek()
```
    Specified by:
    
    peek in interface Queue<E>
  - offer
```
public boolean offer(E e,
                     long timeout,
                     TimeUnit unit)
              throws InterruptedException
```
    Specified by:
    
    offer in interface BlockingQueue<E>
    
    Throws:
    
    InterruptedException
  - take
```
public E take()
       throws InterruptedException
```
    Specified by:
    
    take in interface BlockingQueue<E>
    
    Throws:
    
    InterruptedException
  - poll
```
public E poll(long timeout,
              TimeUnit unit)
       throws InterruptedException
```
    Specified by:
    
    poll in interface BlockingQueue<E>
    
    Throws:
    
    InterruptedException
  - remainingCapacity
```
public int remainingCapacity()
```
    Specified by:
    
    remainingCapacity in interface BlockingQueue<E>
  - remove
```
public boolean remove(Object o)
```
    Specified by:
    
    remove in interface Collection<E>
    
    Specified by:
    
    remove in interface BlockingQueue<E>
  - containsAll
```
public boolean containsAll(Collection<?> c)
```
    Specified by:
    
    containsAll in interface Collection<E>
  - addAll
```
public boolean addAll(Collection<? extends E> c)
```
    Specified by:
    
    addAll in interface Collection<E>
  - removeAll
```
public boolean removeAll(Collection<?> c)
```
    Specified by:
    
    removeAll in interface Collection<E>
  - retainAll
```
public boolean retainAll(Collection<?> c)
```
    Specified by:
    
    retainAll in interface Collection<E>
  - contains
```
public boolean contains(Object o)
```
    Specified by:
    
    contains in interface Collection<E>
    
    Specified by:
    
    contains in interface BlockingQueue<E>
  - iterator
```
public Iterator<E> iterator()
```
    Specified by:
    
    iterator in interface Iterable<E>
    
    Specified by:
    
    iterator in interface Collection<E>
  - toArray
```
public Object[] toArray()
```
    Specified by:
    
    toArray in interface Collection<E>
  - toArray
```
public <T> T[] toArray(T[] a)
```
    Specified by:
    
    toArray in interface Collection<E>
  - drainTo
```
public int drainTo(Collection<? super E> c)
```
    Specified by:
    
    drainTo in interface BlockingQueue<E>
  - drainTo
```
public int drainTo(Collection<? super E> c,
                   int maxElements)
```
    Specified by:
    
    drainTo in interface BlockingQueue<E>

Class FancyBlockingQueue<E>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Collection

Methods inherited from interface java.lang.Iterable

Field Detail

backingQueue

consumers

currentStep

step

state

currentConsumers

isFirst

isDone

barrier

secondary

numElementsReady

numElementsDrained

bypassMode

isDebug

lock

Constructor Detail

FancyBlockingQueue

FancyBlockingQueue

Method Detail

add

offer

remove

fallbackToSingleConsumerMode

registerConsumers

put

isEmpty

synchronize

poll

element

clear

size

peek

offer

take

poll

remainingCapacity

remove

containsAll

addAll

removeAll

retainAll

contains

iterator

toArray

toArray

drainTo

drainTo