DefaultBroadcaster (atmosphere-runtime 1.0.21 API)

java.lang.Object
- org.atmosphere.cpr.DefaultBroadcaster

All Implemented Interfaces:

Broadcaster

Direct Known Subclasses:

AbstractBroadcasterProxy, ExcludeSessionBroadcaster, SimpleBroadcaster
```
public class DefaultBroadcaster
extends java.lang.Object
implements Broadcaster
```
Broadcaster implementation.
Broadcast messages to suspended response using the caller's Thread. This basic Broadcaster use an ExecutorService to broadcast message, hence the broadcast operation is asynchronous. Make sure you block on broadcast(Object).get()} if you need synchronous operations.

Author:

Jeanfrancois Arcand

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected static class DefaultBroadcaster.AsyncWriteToken

static class DefaultBroadcaster.Entry
- Nested classes/interfaces inherited from interface org.atmosphere.cpr.Broadcaster
  Broadcaster.POLICY, Broadcaster.SCOPE

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`DefaultBroadcaster.AsyncWriteToken`
`static class`	`DefaultBroadcaster.Entry`

Field Summary

Fields
Modifier and Type	Field and Description
`static java.lang.String`	`ASYNC_TOKEN`
`protected java.util.concurrent.Future<?>[]`	`asyncWriteFuture`
`protected BroadcasterConfig`	`bc`
`protected java.util.concurrent.ConcurrentLinkedQueue<BroadcasterListener>`	`broadcasterListeners`
`protected java.util.concurrent.ConcurrentLinkedQueue<DefaultBroadcaster.Entry>`	`broadcastOnResume`
`static java.lang.String`	`CACHED`
`protected BroadcasterCache.STRATEGY`	`cacheStrategy`
`protected AtmosphereConfig`	`config`
`protected java.util.concurrent.ConcurrentLinkedQueue<DefaultBroadcaster.Entry>`	`delayedBroadcast`
`protected java.util.concurrent.atomic.AtomicBoolean`	`destroyed`
`protected java.util.concurrent.atomic.AtomicInteger`	`dispatchThread`
`protected java.util.concurrent.ConcurrentLinkedQueue<BroadcasterLifeCyclePolicyListener>`	`lifeCycleListeners`
`protected java.util.concurrent.BlockingQueue<DefaultBroadcaster.Entry>`	`messages`
`protected java.lang.String`	`name`
`protected AtmosphereResource`	`noOpsResource`
`protected java.util.concurrent.Future<?>[]`	`notifierFuture`
`protected java.util.concurrent.atomic.AtomicBoolean`	`outOfOrderBroadcastSupported`
`protected java.util.concurrent.ConcurrentLinkedQueue<AtmosphereResource>`	`resources`
`protected Broadcaster.SCOPE`	`scope`
`protected java.util.concurrent.atomic.AtomicBoolean`	`started`
`protected org.atmosphere.cpr.DefaultBroadcaster.WriteQueue`	`uniqueWriteQueue`
`protected java.net.URI`	`uri`
`protected int`	`waitTime`
`protected java.util.concurrent.ConcurrentHashMap<java.lang.String,org.atmosphere.cpr.DefaultBroadcaster.WriteQueue>`	`writeQueues`
`protected int`	`writeTimeoutInSecond`

Constructor Summary

Constructors
Constructor and Description
`DefaultBroadcaster(java.lang.String name, AtmosphereConfig config)`
`DefaultBroadcaster(java.lang.String name, java.net.URI uri, AtmosphereConfig config)`

Method Summary

Methods
Modifier and Type	Method and Description
`Broadcaster`	`addAtmosphereResource(AtmosphereResource r)` Add a `AtmosphereResource` to the list of item to be notified when the `Broadcaster.broadcast(T)` is invoked.
`void`	`addBroadcasterLifeCyclePolicyListener(BroadcasterLifeCyclePolicyListener b)` Add a `BroadcasterLifeCyclePolicyListener`
`Broadcaster`	`addBroadcasterListener(BroadcasterListener b)` Add a `BroadcasterListener`
`protected void`	`afterFilterCacheEntry(AtmosphereResource r, java.lang.Object finalMsg, UUIDBroadcasterCache.CacheMessage cacheMessage)`
`<T> java.util.concurrent.Future<T>`	`awaitAndBroadcast(T t, long time, java.util.concurrent.TimeUnit timeUnit)` Await for available `AtmosphereResource` before broadcasting.
`<T> java.util.concurrent.Future<T>`	`broadcast(T msg)` Broadcast the `Object` to all suspended response, e.g.
`<T> java.util.concurrent.Future<T>`	`broadcast(T msg, AtmosphereResource r)` Broadcast the `Object` to all suspended response, e.g.
`<T> java.util.concurrent.Future<T>`	`broadcast(T msg, java.util.Set<AtmosphereResource> subset)` Broadcast the `Object` to all suspended response, e.g.
`protected void`	`broadcastOnResume(AtmosphereResource r)`
`<T> java.util.concurrent.Future<T>`	`broadcastOnResume(T msg)` Broadcast the `Object` when an `AtmosphereResource` is resumed by a timeout or when using `AtmosphereResource.resume()`
`protected void`	`cacheAndSuspend(AtmosphereResource r)` Look in the cache to see of there are messages available, and takes the appropriate actions.
`void`	`cacheLostMessage(AtmosphereResource r)` Cache the message because an unexpected exception occurred.
`void`	`cacheLostMessage(AtmosphereResource r, boolean force)` Cache the message because an unexpected exception occurred.
`void`	`cacheLostMessage(AtmosphereResource r, DefaultBroadcaster.AsyncWriteToken token)` Cache the message because an unexpected exception occurred.
`void`	`cacheLostMessage(AtmosphereResource r, DefaultBroadcaster.AsyncWriteToken token, boolean force)` Cache the message because an unexpected exception occurred.
`protected boolean`	`checkCachedAndPush(AtmosphereResource r, AtmosphereResourceEvent e)` Return false if no cached messages has been found, true if cached.
`protected BroadcasterConfig`	`createBroadcasterConfig(AtmosphereConfig config)` Create `BroadcasterConfig`
`<T> java.util.concurrent.Future<T>`	`delayBroadcast(T o)` Delay the broadcast operation.
`<T> java.util.concurrent.Future<T>`	`delayBroadcast(T o, long delay, java.util.concurrent.TimeUnit t)` Delay the broadcast operation.
`protected void`	`deliverPush(DefaultBroadcaster.Entry entry, boolean rec)`
`void`	`destroy()` Destroy this instance and shutdown it's associated `ExecutorService`
`protected void`	`dispatchMessages(DefaultBroadcaster.Entry e)`
`protected void`	`entryDone(BroadcasterFuture<?> f)`
`protected void`	`executeAsyncWrite(DefaultBroadcaster.AsyncWriteToken token)`
`protected java.lang.Object`	`filter(java.lang.Object msg)` Invoke the `BroadcastFilter`
`void`	`finalize()`
`protected BroadcasterFuture<java.lang.Object>`	`futureDone(java.lang.Object msg)`
`protected java.lang.Runnable`	`getAsyncWriteHandler(org.atmosphere.cpr.DefaultBroadcaster.WriteQueue writeQueue)`
`java.util.Collection<AtmosphereResource>`	`getAtmosphereResources()` Return an `List` of `AtmosphereResource`.
`BroadcasterConfig`	`getBroadcasterConfig()` Return the current `BroadcasterConfig`
`protected java.lang.Runnable`	`getBroadcastHandler()`
`java.lang.String`	`getID()` Return the id of this `Broadcaster`
`Broadcaster.SCOPE`	`getScope()` Return the `Broadcaster.SCOPE`
`protected boolean`	`invokeFiltersAndCache(DefaultBroadcaster.Entry entry)`
`protected void`	`invokeOnStateChange(AtmosphereResource r, AtmosphereResourceEvent e)`
`boolean`	`isDestroyed()` Return true if that `Broadcaster` has been destroyed
`protected void`	`killReactiveThreads()`
`void`	`onException(java.lang.Throwable t, AtmosphereResource ar)`
`void`	`onException(java.lang.Throwable t, AtmosphereResource ar, boolean notifyAndCache)`
`protected java.lang.Object`	`perRequestFilter(AtmosphereResource r, DefaultBroadcaster.Entry msg, boolean cache)`
`protected void`	`prepareInvokeOnStateChange(AtmosphereResource r, AtmosphereResourceEvent e)`
`void`	`push(DefaultBroadcaster.Entry entry)`
`protected void`	`queueWriteIO(AtmosphereResource r, java.lang.Object finalMsg, DefaultBroadcaster.Entry entry)`
`protected int`	`reactiveThreadsCount()` Return the default number of reactive threads that will be waiting for work when a broadcast operation is executed.
`void`	`releaseExternalResources()` Release external resources associated with this Broadcaster.
`Broadcaster`	`removeAtmosphereResource(AtmosphereResource r)` Remove a `AtmosphereResource` from the list of item to be notified when the `Broadcaster.broadcast(T)` is invoked.
`protected Broadcaster`	`removeAtmosphereResource(AtmosphereResource r, boolean executeDone)`
`void`	`removeBroadcasterLifeCyclePolicyListener(BroadcasterLifeCyclePolicyListener b)` Remove a `BroadcasterLifeCyclePolicyListener`
`Broadcaster`	`removeBroadcasterListener(BroadcasterListener b)` Remove a `BroadcasterListener`
`void`	`resumeAll()` Resume all suspended responses (`AtmosphereResource`) added via `Broadcaster.addAtmosphereResource(org.atmosphere.cpr.AtmosphereResource)`.
`protected boolean`	`retrieveTrackedBroadcast(AtmosphereResource r, AtmosphereResourceEvent e)`
`java.util.concurrent.Future<?>`	`scheduleFixedBroadcast(java.lang.Object o, long waitFor, long period, java.util.concurrent.TimeUnit t)` Broadcast periodically.
`java.util.concurrent.Future<?>`	`scheduleFixedBroadcast(java.lang.Object o, long period, java.util.concurrent.TimeUnit t)` Broadcast periodically.
`Broadcaster`	`setBroadcasterCacheStrategy(BroadcasterCache.STRATEGY cacheStrategy)` Set the `BroadcasterCache.STRATEGY`
`void`	`setBroadcasterConfig(BroadcasterConfig bc)` Set the `BroadcasterConfig` instance.
`void`	`setBroadcasterLifeCyclePolicy(BroadcasterLifeCyclePolicy lifeCyclePolicy)` Set the `BroadcasterLifeCyclePolicy`.
`void`	`setID(java.lang.String id)` Set the id of this `Broadcaster`
`void`	`setScope(Broadcaster.SCOPE scope)` Set the scope.
`void`	`setSuspendPolicy(long maxSuspendResource, Broadcaster.POLICY policy)` Set the maximum number of suspended `AtmosphereResource`.
`protected void`	`spawnReactor()`
`protected void`	`start()`
`java.lang.String`	`toString()`
`protected void`	`trackBroadcastMessage(AtmosphereResource r, java.lang.Object msg)`

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

- Field Detail
  - CACHED
```
public static final java.lang.String CACHED
```
  - ASYNC_TOKEN
```
public static final java.lang.String ASYNC_TOKEN
```
  - resources
```
protected final java.util.concurrent.ConcurrentLinkedQueue<AtmosphereResource> resources
```
  - bc
```
protected BroadcasterConfig bc
```
  - messages
```
protected final java.util.concurrent.BlockingQueue<DefaultBroadcaster.Entry> messages
```
  - broadcasterListeners
```
protected final java.util.concurrent.ConcurrentLinkedQueue<BroadcasterListener> broadcasterListeners
```
  - started
```
protected final java.util.concurrent.atomic.AtomicBoolean started
```
  - destroyed
```
protected final java.util.concurrent.atomic.AtomicBoolean destroyed
```
  - scope
```
protected Broadcaster.SCOPE scope
```
  - name
```
protected java.lang.String name
```
  - delayedBroadcast
```
protected final java.util.concurrent.ConcurrentLinkedQueue<DefaultBroadcaster.Entry> delayedBroadcast
```
  - broadcastOnResume
```
protected final java.util.concurrent.ConcurrentLinkedQueue<DefaultBroadcaster.Entry> broadcastOnResume
```
  - lifeCycleListeners
```
protected final java.util.concurrent.ConcurrentLinkedQueue<BroadcasterLifeCyclePolicyListener> lifeCycleListeners
```
  - writeQueues
```
protected final java.util.concurrent.ConcurrentHashMap<java.lang.String,org.atmosphere.cpr.DefaultBroadcaster.WriteQueue> writeQueues
```
  - uniqueWriteQueue
```
protected final org.atmosphere.cpr.DefaultBroadcaster.WriteQueue uniqueWriteQueue
```
  - dispatchThread
```
protected final java.util.concurrent.atomic.AtomicInteger dispatchThread
```
  - notifierFuture
```
protected java.util.concurrent.Future<?>[] notifierFuture
```
  - asyncWriteFuture
```
protected java.util.concurrent.Future<?>[] asyncWriteFuture
```
  - uri
```
protected java.net.URI uri
```
  - config
```
protected AtmosphereConfig config
```
  - cacheStrategy
```
protected BroadcasterCache.STRATEGY cacheStrategy
```
  - outOfOrderBroadcastSupported
```
protected final java.util.concurrent.atomic.AtomicBoolean outOfOrderBroadcastSupported
```
  - writeTimeoutInSecond
```
protected int writeTimeoutInSecond
```
  - noOpsResource
```
protected final AtmosphereResource noOpsResource
```
  - waitTime
```
protected int waitTime
```
- Constructor Detail
  - DefaultBroadcaster
```
public DefaultBroadcaster(java.lang.String name,
                  java.net.URI uri,
                  AtmosphereConfig config)
```
  - DefaultBroadcaster
```
public DefaultBroadcaster(java.lang.String name,
                  AtmosphereConfig config)
```
- Method Detail
  - createBroadcasterConfig
```
protected BroadcasterConfig createBroadcasterConfig(AtmosphereConfig config)
```
    Create BroadcasterConfig
    
    Parameters:
    config - the AtmosphereConfig
    
    Returns:
    an instance of BroadcasterConfig
  - setBroadcasterCacheStrategy
```
public Broadcaster setBroadcasterCacheStrategy(BroadcasterCache.STRATEGY cacheStrategy)
```
    Set the BroadcasterCache.STRATEGY
    
    Parameters:
    cacheStrategy - the BroadcasterCache.STRATEGY
    
    Returns:
    this
  - destroy
```
public void destroy()
```
    Destroy this instance and shutdown it's associated ExecutorService
    
    Specified by:
    
    destroy in interface Broadcaster
  - getAtmosphereResources
```
public java.util.Collection<AtmosphereResource> getAtmosphereResources()
```
    Return an List of AtmosphereResource.
    
    Specified by:
    
    getAtmosphereResources in interface Broadcaster
    
    Returns:
    List of AtmosphereResource associated with this Broadcaster.
    See Also:
    Broadcaster.addAtmosphereResource(AtmosphereResource)
  - setScope
```
public void setScope(Broadcaster.SCOPE scope)
```
    Set the scope.
    
    Specified by:
    
    setScope in interface Broadcaster
    
    Parameters:
    scope - Broadcaster.SCOPE to set.
  - getScope
```
public Broadcaster.SCOPE getScope()
```
    Return the Broadcaster.SCOPE
    
    Specified by:
    
    getScope in interface Broadcaster
    
    Returns:
    Broadcaster.SCOPE of Broadcaster.
  - setID
```
public void setID(java.lang.String id)
```
    Set the id of this Broadcaster
    
    Specified by:
    
    setID in interface Broadcaster
    
    Parameters:
    id - ID of this Broadcaster
  - getID
```
public java.lang.String getID()
```
    Return the id of this Broadcaster
    
    Specified by:
    
    getID in interface Broadcaster
    
    Returns:
    the id of this Broadcaster
  - resumeAll
```
public void resumeAll()
```
    Resume all suspended responses (AtmosphereResource) added via Broadcaster.addAtmosphereResource(org.atmosphere.cpr.AtmosphereResource).
    
    Specified by:
    
    resumeAll in interface Broadcaster
  - releaseExternalResources
```
public void releaseExternalResources()
```
    Release external resources associated with this Broadcaster. This is useful when a Broadcaster no longer have suspended AtmosphereResource and some resource (like database connections, JMS queue, etc.) needs to be closed.
    
    Specified by:
    
    releaseExternalResources in interface Broadcaster
  - setBroadcasterLifeCyclePolicy
```
public void setBroadcasterLifeCyclePolicy(BroadcasterLifeCyclePolicy lifeCyclePolicy)
```
    Set the BroadcasterLifeCyclePolicy. Make sure you are selecting the right policy to avoid unexpected situation.
    
    Specified by:
    
    setBroadcasterLifeCyclePolicy in interface Broadcaster
    
    Parameters:
    lifeCyclePolicy - a BroadcasterLifeCyclePolicy
  - addBroadcasterLifeCyclePolicyListener
```
public void addBroadcasterLifeCyclePolicyListener(BroadcasterLifeCyclePolicyListener b)
```
    Add a BroadcasterLifeCyclePolicyListener
    
    Specified by:
    
    addBroadcasterLifeCyclePolicyListener in interface Broadcaster
    
    Parameters:
    b - a BroadcasterLifeCyclePolicyListener
  - removeBroadcasterLifeCyclePolicyListener
```
public void removeBroadcasterLifeCyclePolicyListener(BroadcasterLifeCyclePolicyListener b)
```
    Remove a BroadcasterLifeCyclePolicyListener
    
    Specified by:
    
    removeBroadcasterLifeCyclePolicyListener in interface Broadcaster
    
    Parameters:
    b - a BroadcasterLifeCyclePolicyListener
  - isDestroyed
```
public boolean isDestroyed()
```
    Return true if that Broadcaster has been destroyed
    
    Specified by:
    
    isDestroyed in interface Broadcaster
    
    Returns:
    true if that Broadcaster has been destroyed
  - awaitAndBroadcast
```
public <T> java.util.concurrent.Future<T> awaitAndBroadcast(T t,
                                                   long time,
                                                   java.util.concurrent.TimeUnit timeUnit)
```
    Await for available AtmosphereResource before broadcasting. This method will block until Broadcaster.addAtmosphereResource(AtmosphereResource) gets invoked.
    
    Specified by:
    
    awaitAndBroadcast in interface Broadcaster
  - addBroadcasterListener
```
public Broadcaster addBroadcasterListener(BroadcasterListener b)
```
    Add a BroadcasterListener
    
    Specified by:
    
    addBroadcasterListener in interface Broadcaster
    
    Parameters:
    b - a BroadcasterListener
    
    Returns:
    this
  - removeBroadcasterListener
```
public Broadcaster removeBroadcasterListener(BroadcasterListener b)
```
    Remove a BroadcasterListener
    
    Specified by:
    
    removeBroadcasterListener in interface Broadcaster
    
    Parameters:
    b - a BroadcasterListener
    
    Returns:
    this
  - getBroadcastHandler
```
protected java.lang.Runnable getBroadcastHandler()
```
  - getAsyncWriteHandler
```
protected java.lang.Runnable getAsyncWriteHandler(org.atmosphere.cpr.DefaultBroadcaster.WriteQueue writeQueue)
```
  - start
```
protected void start()
```
  - spawnReactor
```
protected void spawnReactor()
```
  - killReactiveThreads
```
protected void killReactiveThreads()
```
  - reactiveThreadsCount
```
protected int reactiveThreadsCount()
```
    Return the default number of reactive threads that will be waiting for work when a broadcast operation is executed. Setting this value larger than 1 will produce out of order broadcast delivery.
    
    Returns:
    the default number of reactive threads
  - finalize
```
public void finalize()
              throws java.lang.Throwable
```
    Overrides:
    
    finalize in class java.lang.Object
    
    Throws:
    
    java.lang.Throwable
  - push
```
public void push(DefaultBroadcaster.Entry entry)
```
  - deliverPush
```
protected void deliverPush(DefaultBroadcaster.Entry entry,
               boolean rec)
```
  - afterFilterCacheEntry
```
protected void afterFilterCacheEntry(AtmosphereResource r,
                         java.lang.Object finalMsg,
                         UUIDBroadcasterCache.CacheMessage cacheMessage)
```
  - invokeFiltersAndCache
```
protected boolean invokeFiltersAndCache(DefaultBroadcaster.Entry entry)
```
  - queueWriteIO
```
protected void queueWriteIO(AtmosphereResource r,
                java.lang.Object finalMsg,
                DefaultBroadcaster.Entry entry)
                     throws java.lang.InterruptedException
```
    Throws:
    
    java.lang.InterruptedException
  - perRequestFilter
```
protected java.lang.Object perRequestFilter(AtmosphereResource r,
                                DefaultBroadcaster.Entry msg,
                                boolean cache)
```
  - executeAsyncWrite
```
protected void executeAsyncWrite(DefaultBroadcaster.AsyncWriteToken token)
```
  - checkCachedAndPush
```
protected boolean checkCachedAndPush(AtmosphereResource r,
                         AtmosphereResourceEvent e)
```
    Return false if no cached messages has been found, true if cached.
    
    Parameters:
    r -
    e -
    
    Returns:
    false if no cached messages has been found, true if cached.
  - retrieveTrackedBroadcast
```
protected boolean retrieveTrackedBroadcast(AtmosphereResource r,
                               AtmosphereResourceEvent e)
```
  - trackBroadcastMessage
```
protected void trackBroadcastMessage(AtmosphereResource r,
                         java.lang.Object msg)
```
  - invokeOnStateChange
```
protected void invokeOnStateChange(AtmosphereResource r,
                       AtmosphereResourceEvent e)
```
  - prepareInvokeOnStateChange
```
protected void prepareInvokeOnStateChange(AtmosphereResource r,
                              AtmosphereResourceEvent e)
```
  - onException
```
public void onException(java.lang.Throwable t,
               AtmosphereResource ar)
```
  - onException
```
public void onException(java.lang.Throwable t,
               AtmosphereResource ar,
               boolean notifyAndCache)
```
  - cacheLostMessage
```
public void cacheLostMessage(AtmosphereResource r)
```
    Cache the message because an unexpected exception occurred.
    
    Parameters:
    r - AtmosphereResource
  - cacheLostMessage
```
public void cacheLostMessage(AtmosphereResource r,
                    boolean force)
```
    Cache the message because an unexpected exception occurred.
    
    Parameters:
    r - AtmosphereResource
  - cacheLostMessage
```
public void cacheLostMessage(AtmosphereResource r,
                    DefaultBroadcaster.AsyncWriteToken token)
```
    Cache the message because an unexpected exception occurred.
    
    Parameters:
    r - AtmosphereResource
  - cacheLostMessage
```
public void cacheLostMessage(AtmosphereResource r,
                    DefaultBroadcaster.AsyncWriteToken token,
                    boolean force)
```
    Cache the message because an unexpected exception occurred.
    
    Parameters:
    r - AtmosphereResource
  - setSuspendPolicy
```
public void setSuspendPolicy(long maxSuspendResource,
                    Broadcaster.POLICY policy)
```
    Set the maximum number of suspended AtmosphereResource. If the max is reached, Atmosphere will either resume AtmosphereResource using Broadcaster.POLICY.FIFO (first in first out) or Broadcaster.POLICY.REJECT the AtmosphereResource.
    By default the number is uunlimited.
    
    Specified by:
    
    setSuspendPolicy in interface Broadcaster
    
    Parameters:
    maxSuspendResource - max suspended
  - broadcast
```
public <T> java.util.concurrent.Future<T> broadcast(T msg)
```
    Broadcast the Object to all suspended response, e.g. invoke AtmosphereHandler.onStateChange(org.atmosphere.cpr.AtmosphereResourceEvent).
    
    Specified by:
    
    broadcast in interface Broadcaster
    
    Parameters:
    msg - and Object to be broadcasted.
    
    Returns:
    a Future that can be used to synchronize using the Future.get()
  - futureDone
```
protected BroadcasterFuture<java.lang.Object> futureDone(java.lang.Object msg)
```
  - dispatchMessages
```
protected void dispatchMessages(DefaultBroadcaster.Entry e)
```
  - filter
```
protected java.lang.Object filter(java.lang.Object msg)
```
    Invoke the BroadcastFilter
    
    Parameters:
    msg -
    
    Returns:
  - broadcast
```
public <T> java.util.concurrent.Future<T> broadcast(T msg,
                                           AtmosphereResource r)
```
    Broadcast the Object to all suspended response, e.g. invoke AtmosphereHandler.onStateChange(org.atmosphere.cpr.AtmosphereResourceEvent) with an instance of AtmosphereResource, representing a single suspended response..
    
    Specified by:
    
    broadcast in interface Broadcaster
    
    Parameters:
    msg - and Object to be broadcasted.
    r - an AtmosphereResource
    
    Returns:
    a Future that can be used to synchronize using the Future.get()
  - broadcastOnResume
```
public <T> java.util.concurrent.Future<T> broadcastOnResume(T msg)
```
    Broadcast the Object when an AtmosphereResource is resumed by a timeout or when using AtmosphereResource.resume()
    
    Specified by:
    
    broadcastOnResume in interface Broadcaster
    
    Parameters:
    msg - and Object to be broadcasted.
    
    Returns:
    a Future that can be used to synchronize using the Future.get()
  - broadcastOnResume
```
protected void broadcastOnResume(AtmosphereResource r)
```
  - broadcast
```
public <T> java.util.concurrent.Future<T> broadcast(T msg,
                                           java.util.Set<AtmosphereResource> subset)
```
    Broadcast the Object to all suspended response, e.g. invoke AtmosphereHandler.onStateChange(org.atmosphere.cpr.AtmosphereResourceEvent) with a Set of AtmosphereResource, representing a set of AtmosphereHandler.
    
    Specified by:
    
    broadcast in interface Broadcaster
    
    Parameters:
    msg - and Object to be broadcasted.
    subset - a Set of AtmosphereResource
    
    Returns:
    a Future that can be used to synchronize using the Future.get()
  - addAtmosphereResource
```
public Broadcaster addAtmosphereResource(AtmosphereResource r)
```
    Add a AtmosphereResource to the list of item to be notified when the Broadcaster.broadcast(T) is invoked. It is strongly recommended to suspend the AtmosphereResource before adding it to a Broadcaster.
    
    Specified by:
    
    addAtmosphereResource in interface Broadcaster
    
    Parameters:
    r - an AtmosphereResource
    
    Returns:
    this
  - cacheAndSuspend
```
protected void cacheAndSuspend(AtmosphereResource r)
```
    Look in the cache to see of there are messages available, and takes the appropriate actions.
    
    Parameters:
    r - AtmosphereResource
  - entryDone
```
protected void entryDone(BroadcasterFuture<?> f)
```
  - removeAtmosphereResource
```
public Broadcaster removeAtmosphereResource(AtmosphereResource r)
```
    Remove a AtmosphereResource from the list of item to be notified when the Broadcaster.broadcast(T) is invoked.
    
    Specified by:
    
    removeAtmosphereResource in interface Broadcaster
    
    Parameters:
    r - an AtmosphereResource
    
    Returns:
    this
  - removeAtmosphereResource
```
protected Broadcaster removeAtmosphereResource(AtmosphereResource r,
                                   boolean executeDone)
```
  - setBroadcasterConfig
```
public void setBroadcasterConfig(BroadcasterConfig bc)
```
    Set the BroadcasterConfig instance.
    
    Specified by:
    
    setBroadcasterConfig in interface Broadcaster
    
    Parameters:
    bc -
  - getBroadcasterConfig
```
public BroadcasterConfig getBroadcasterConfig()
```
    Return the current BroadcasterConfig
    
    Specified by:
    
    getBroadcasterConfig in interface Broadcaster
    
    Returns:
    the current BroadcasterConfig
  - delayBroadcast
```
public <T> java.util.concurrent.Future<T> delayBroadcast(T o)
```
    Delay the broadcast operation. The Object will be broadcasted when the first Broadcaster.broadcast(java.lang.Object) is invoked.
    
    Specified by:
    
    delayBroadcast in interface Broadcaster
    
    Parameters:
    o - and Object to be broadcasted.
    
    Returns:
    a Future that can be used to synchronize using the Future.get()
  - delayBroadcast
```
public <T> java.util.concurrent.Future<T> delayBroadcast(T o,
                                                long delay,
                                                java.util.concurrent.TimeUnit t)
```
    Delay the broadcast operation. The Object will be broadcasted once the specified delay expires or when the first Broadcaster.broadcast(java.lang.Object)
    
    Specified by:
    
    delayBroadcast in interface Broadcaster
    
    Parameters:
    o - and Object to be broadcasted.
    delay - Amount of time to delay.
    t - a TimeUnit of delay.
    
    Returns:
    a Future that can be used to synchronize using the Future.get()
  - scheduleFixedBroadcast
```
public java.util.concurrent.Future<?> scheduleFixedBroadcast(java.lang.Object o,
                                                    long period,
                                                    java.util.concurrent.TimeUnit t)
```
    Broadcast periodically. The Object will be broadcasted after every period specified time frame expires. If the TimeUnit is set null, the Object will be broadcasted when the first Broadcaster.broadcast(java.lang.Object) is invoked.
    
    Specified by:
    
    scheduleFixedBroadcast in interface Broadcaster
    
    Parameters:
    o - and Object to be broadcasted.
    period - Every so often broadcast.
    t - a TimeUnit of period.
    
    Returns:
    a Future that can be used to synchronize using the Future.get()
  - scheduleFixedBroadcast
```
public java.util.concurrent.Future<?> scheduleFixedBroadcast(java.lang.Object o,
                                                    long waitFor,
                                                    long period,
                                                    java.util.concurrent.TimeUnit t)
```
    Broadcast periodically. The Object will be broadcasted after every period specified time frame expires. If the TimeUnit is set null, the Object will be broadcasted when the first Broadcaster.broadcast(java.lang.Object) * is invoked.
    
    Specified by:
    
    scheduleFixedBroadcast in interface Broadcaster
    
    Parameters:
    o - and Object to be broadcasted.
    waitFor - Wait for that long before first broadcast.
    period - The period inbetween broadcast.
    t - a TimeUnit of waitFor and period.
    
    Returns:
    a Future that can be used to synchronize using the Future.get()
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object

Class DefaultBroadcaster

Nested Class Summary

Nested classes/interfaces inherited from interface org.atmosphere.cpr.Broadcaster

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

CACHED

ASYNC_TOKEN

resources

bc

messages

broadcasterListeners

started

destroyed

scope

name

delayedBroadcast

broadcastOnResume

lifeCycleListeners

writeQueues

uniqueWriteQueue

dispatchThread

notifierFuture

asyncWriteFuture

uri

config

cacheStrategy

outOfOrderBroadcastSupported

writeTimeoutInSecond

noOpsResource

waitTime

Constructor Detail

DefaultBroadcaster

DefaultBroadcaster

Method Detail

createBroadcasterConfig

setBroadcasterCacheStrategy

destroy

getAtmosphereResources

setScope

getScope

setID

getID

resumeAll

releaseExternalResources

setBroadcasterLifeCyclePolicy

addBroadcasterLifeCyclePolicyListener

removeBroadcasterLifeCyclePolicyListener

isDestroyed

awaitAndBroadcast

addBroadcasterListener

removeBroadcasterListener

getBroadcastHandler

getAsyncWriteHandler

start

spawnReactor

killReactiveThreads

reactiveThreadsCount

finalize

push

deliverPush

afterFilterCacheEntry

invokeFiltersAndCache

queueWriteIO

perRequestFilter

executeAsyncWrite

checkCachedAndPush

retrieveTrackedBroadcast

trackBroadcastMessage

invokeOnStateChange

prepareInvokeOnStateChange

onException

onException

cacheLostMessage

cacheLostMessage

cacheLostMessage

cacheLostMessage

setSuspendPolicy