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
```
The default Broadcaster implementation.
Broadcast messages to suspended responses using the caller's Thread. This basic Broadcaster use an ExecutorService to broadcast messages, 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 Description

protected static class DefaultBroadcaster.AsyncWriteToken

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

Field Summary

Fields
Modifier and Type	Field	Description
`protected java.util.concurrent.Future<?>[]`	`asyncWriteFuture`
`protected BroadcasterConfig`	`bc`
`protected java.util.Collection<BroadcasterListener>`	`broadcasterListeners`
`protected java.util.concurrent.ConcurrentLinkedQueue<Deliver>`	`broadcastOnResume`
`static java.lang.String`	`CACHED`
`protected boolean`	`candidateForPoolable`
`protected AtmosphereConfig`	`config`
`protected java.util.concurrent.ConcurrentLinkedQueue<Deliver>`	`delayedBroadcast`
`protected java.util.concurrent.atomic.AtomicBoolean`	`destroyed`
`protected java.util.concurrent.atomic.AtomicInteger`	`dispatchThread`
`protected java.util.concurrent.atomic.AtomicBoolean`	`initialized`
`protected java.util.concurrent.ConcurrentLinkedQueue<BroadcasterLifeCyclePolicyListener>`	`lifeCycleListeners`
`protected java.util.concurrent.BlockingQueue<Deliver>`	`messages`
`protected java.lang.String`	`name`
`protected java.util.concurrent.Future<?>[]`	`notifierFuture`
`static int`	`POLLING_DEFAULT`
`protected java.util.concurrent.ConcurrentLinkedQueue<AtmosphereResource>`	`resources`
`protected Broadcaster.SCOPE`	`scope`
`protected boolean`	`sharedListeners`
`protected java.util.concurrent.atomic.AtomicBoolean`	`started`
`protected DefaultBroadcaster.WriteQueue`	`uniqueWriteQueue`
`protected java.net.URI`	`uri`
`protected java.lang.String`	`usingTokenIdForAttribute`
`protected int`	`waitTime`
`protected java.util.concurrent.ConcurrentHashMap<java.lang.String,DefaultBroadcaster.WriteQueue>`	`writeQueues`
`protected int`	`writeTimeoutInSecond`

Fields inherited from interface org.atmosphere.cpr.Broadcaster
ROOT_MASTER

Constructor Summary

Constructors
Constructor Description

DefaultBroadcaster()

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`Broadcaster`	`addAtmosphereResource(AtmosphereResource r)`	Add a `AtmosphereResource` to the list of items to be notified when the `Broadcaster.broadcast(java.lang.Object)` is invoked.
`void`	`addBroadcasterLifeCyclePolicyListener(BroadcasterLifeCyclePolicyListener b)`	Add a `BroadcasterLifeCyclePolicyListener`.
`Broadcaster`	`addBroadcasterListener(BroadcasterListener b)`	Add a `BroadcasterListener`.
`java.util.concurrent.Future<java.lang.Object>`	`awaitAndBroadcast(java.lang.Object t, long time, java.util.concurrent.TimeUnit timeUnit)`	Await for available `AtmosphereResource` before broadcasting.
`java.util.concurrent.Future<java.lang.Object>`	`broadcast(java.lang.Object msg)`	Broadcast the `Object` to all suspended responses, eg.
`java.util.concurrent.Future<java.lang.Object>`	`broadcast(java.lang.Object msg, java.util.Set<AtmosphereResource> subset)`	Broadcast the `Object` to all suspended response, eg.
`java.util.concurrent.Future<java.lang.Object>`	`broadcast(java.lang.Object msg, AtmosphereResource r)`	Broadcast the `Object` to all suspended responses, eg.
`java.util.Collection<BroadcasterListener>`	`broadcasterListeners()`
`java.util.concurrent.Future<java.lang.Object>`	`broadcastOnResume(java.lang.Object msg)`	Broadcast the `Object` when an `AtmosphereResource` is resumed by a timeout or when using `AtmosphereResource.resume()`.
`protected void`	`broadcastOnResume(AtmosphereResource r)`
`protected void`	`cacheAndSuspend(AtmosphereResource r)`	Look in the cache to see if there are messages available, and take the appropriate actions.
`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`	`cacheMessageOnIOException(java.lang.Throwable cause)`
`protected boolean`	`checkCachedAndPush(AtmosphereResource r, AtmosphereResourceEvent e)`
`protected BroadcasterConfig`	`createBroadcasterConfig(AtmosphereConfig config)`	Create `BroadcasterConfig`.
`java.util.concurrent.Future<?>`	`currentLifecycleTask()`
`DefaultBroadcaster`	`currentLifecycleTask(java.util.concurrent.Future<?> currentLifecycleTask)`
`java.util.concurrent.Future<java.lang.Object>`	`delayBroadcast(java.lang.Object o)`	Delay the broadcast operation.
`java.util.concurrent.Future<java.lang.Object>`	`delayBroadcast(java.lang.Object o, long delay, java.util.concurrent.TimeUnit t)`	Delay the broadcast operation.
`protected void`	`deliverPush(Deliver deliver, boolean rec)`
`void`	`destroy()`	Destroy this instance and shutdown it's associated `ExecutorService`.
`protected void`	`dispatchMessages(Deliver e)`
`protected boolean`	`endBroadcast(Deliver deliver, AtmosphereResource r, CacheMessage cacheMsg, boolean deliverMessage)`
`protected void`	`entryDone(BroadcasterFuture<?> f)`
`protected void`	`executeAsyncWrite(DefaultBroadcaster.AsyncWriteToken token)`
`protected void`	`executeBlockingWrite(AtmosphereResource r, Deliver deliver, java.util.concurrent.atomic.AtomicInteger count)`
`protected java.lang.Object`	`filter(java.lang.Object msg)`	Invoke the `BroadcastFilter`
`protected BroadcasterFuture<java.lang.Object>`	`futureDone(java.lang.Object msg)`
`protected java.lang.Runnable`	`getAsyncWriteHandler(DefaultBroadcaster.WriteQueue writeQueue)`
`java.util.Collection<AtmosphereResource>`	`getAtmosphereResources()`	Return an `List` of `AtmosphereResource`.
`BroadcasterConfig`	`getBroadcasterConfig()`	Return the current `BroadcasterConfig`.
`BroadcasterLifeCyclePolicy`	`getBroadcasterLifeCyclePolicy()`	Get the `BroadcasterLifeCyclePolicy`.
`protected java.lang.Runnable`	`getBroadcastHandler()`
`java.lang.String`	`getID()`	Return the ID of this `Broadcaster`.
`Broadcaster.SCOPE`	`getScope()`	Return the `Broadcaster.SCOPE`.
`Broadcaster`	`initialize(java.lang.String name, java.net.URI uri, AtmosphereConfig config)`	Configure a Broadcaster.
`Broadcaster`	`initialize(java.lang.String name, AtmosphereConfig config)`
`protected void`	`invokeOnStateChange(AtmosphereResource r, AtmosphereResourceEvent e)`
`boolean`	`isDestroyed()`	Return true if this `Broadcaster` has been destroyed.
`protected void`	`killReactiveThreads()`
`LifecycleHandler`	`lifecycleHandler()`
`DefaultBroadcaster`	`lifecycleHandler(LifecycleHandler lifecycleHandler)`
`java.util.concurrent.ConcurrentLinkedQueue<BroadcasterLifeCyclePolicyListener>`	`lifeCycleListeners()`
`BroadcasterLifeCyclePolicy`	`lifeCyclePolicy()`
`java.util.concurrent.BlockingQueue<Deliver>`	`messages()`
`protected void`	`notifyAndAdd(AtmosphereResource r)`
`protected void`	`notifyBroadcastListener()`
`protected void`	`notifyOnAddAtmosphereResourceListener(AtmosphereResource r)`
`protected void`	`notifyOnMessage(Deliver deliver)`
`protected void`	`notifyOnRemoveAtmosphereResourceListener(AtmosphereResource r)`
`void`	`onException(java.lang.Throwable t, AtmosphereResource ar)`
`void`	`onException(java.lang.Throwable t, AtmosphereResource ar, boolean notifyAndCache)`
`boolean`	`outOfOrderBroadcastSupported()`
`protected boolean`	`perRequestFilter(AtmosphereResource r, Deliver msg)`
`Broadcaster.POLICY`	`policy()`
`protected void`	`prepareInvokeOnStateChange(AtmosphereResource r, AtmosphereResourceEvent e)`
`protected void`	`push(Deliver deliver)`
`protected void`	`queueWriteIO(AtmosphereResource r, Deliver deliver, java.util.concurrent.atomic.AtomicInteger count)`
`protected int`	`reactiveThreadsCount()`	Return the default number of reactive threads that will be waiting for work when a broadcast operation is executed.
`java.util.concurrent.atomic.AtomicBoolean`	`recentActivity()`
`void`	`releaseExternalResources()`	Release external resources associated with this Broadcaster.
`Broadcaster`	`removeAtmosphereResource(AtmosphereResource r)`	Remove a `AtmosphereResource` from the list of s to be notified when the `Broadcaster.broadcast(java.lang.Object)` is invoked.
`protected Broadcaster`	`removeAtmosphereResource(AtmosphereResource r, boolean executeDone)`
`void`	`removeBroadcasterLifeCyclePolicyListener(BroadcasterLifeCyclePolicyListener b)`	Remove a `BroadcasterLifeCyclePolicyListener`.
`Broadcaster`	`removeBroadcasterListener(BroadcasterListener b)`	Remove a `BroadcasterListener`.
`Broadcaster`	`rename(java.lang.String id)`	Rename this Broadcaster without invoking it's associated `BroadcasterFactory`.
`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<java.lang.Object>`	`scheduleFixedBroadcast(java.lang.Object o, long waitFor, long period, java.util.concurrent.TimeUnit t)`	Broadcast periodically.
`java.util.concurrent.Future<java.lang.Object>`	`scheduleFixedBroadcast(java.lang.Object o, long period, java.util.concurrent.TimeUnit t)`	Broadcast periodically.
`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`s.
`protected void`	`spawnReactor()`
`protected void`	`start()`
`java.lang.String`	`toString()`
`java.util.concurrent.ConcurrentHashMap<java.lang.String,DefaultBroadcaster.WriteQueue>`	`writeQueues()`

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

- Field Detail
  - POLLING_DEFAULT
```
public static final int POLLING_DEFAULT
```
    See Also:
    
    Constant Field Values
  - CACHED
```
public static final java.lang.String CACHED
```
  - resources
```
protected final java.util.concurrent.ConcurrentLinkedQueue<AtmosphereResource> resources
```
  - bc
```
protected BroadcasterConfig bc
```
  - messages
```
protected final java.util.concurrent.BlockingQueue<Deliver> messages
```
  - broadcasterListeners
```
protected java.util.Collection<BroadcasterListener> broadcasterListeners
```
  - started
```
protected final java.util.concurrent.atomic.AtomicBoolean started
```
  - initialized
```
protected final java.util.concurrent.atomic.AtomicBoolean initialized
```
  - 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<Deliver> delayedBroadcast
```
  - broadcastOnResume
```
protected final java.util.concurrent.ConcurrentLinkedQueue<Deliver> broadcastOnResume
```
  - lifeCycleListeners
```
protected final java.util.concurrent.ConcurrentLinkedQueue<BroadcasterLifeCyclePolicyListener> lifeCycleListeners
```
  - writeQueues
```
protected final java.util.concurrent.ConcurrentHashMap<java.lang.String,DefaultBroadcaster.WriteQueue> writeQueues
```
  - uniqueWriteQueue
```
protected final 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
```
  - writeTimeoutInSecond
```
protected int writeTimeoutInSecond
```
  - waitTime
```
protected int waitTime
```
  - sharedListeners
```
protected boolean sharedListeners
```
  - candidateForPoolable
```
protected boolean candidateForPoolable
```
  - usingTokenIdForAttribute
```
protected final java.lang.String usingTokenIdForAttribute
```
- Constructor Detail
  - DefaultBroadcaster
```
public DefaultBroadcaster()
```
- Method Detail
  - initialize
```
public Broadcaster initialize(java.lang.String name,
                              java.net.URI uri,
                              AtmosphereConfig config)
```
    Description copied from interface: Broadcaster
    
    Configure a Broadcaster.
    
    Specified by:
    
    initialize in interface Broadcaster
    
    config - an AtmosphereConfig
    
    Returns:
    
    a usable Broadcaster.
  - initialize
```
public Broadcaster initialize(java.lang.String name,
                              AtmosphereConfig config)
```
  - createBroadcasterConfig
```
protected BroadcasterConfig createBroadcasterConfig(AtmosphereConfig config)
```
    Create BroadcasterConfig.
    
    Parameters:
    
    config - the AtmosphereConfig
    
    Returns:
    
    an instance of BroadcasterConfig
  - destroy
```
public void destroy()
```
    Description copied from interface: Broadcaster
    
    Destroy this instance and shutdown it's associated ExecutorService.
    
    Specified by:
    
    destroy in interface Broadcaster
  - getAtmosphereResources
```
public java.util.Collection<AtmosphereResource> getAtmosphereResources()
```
    Description copied from interface: Broadcaster
    
    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)
```
    Description copied from interface: Broadcaster
    
    Set the scope.
    
    Specified by:
    
    setScope in interface Broadcaster
    
    Parameters:
    
    scope - Broadcaster.SCOPE to set.
  - getScope
```
public Broadcaster.SCOPE getScope()
```
    Description copied from interface: Broadcaster
    
    Return the Broadcaster.SCOPE.
    
    Specified by:
    
    getScope in interface Broadcaster
    
    Returns:
    
    Broadcaster.SCOPE of Broadcaster.
  - setID
```
public void setID(java.lang.String id)
```
    Description copied from interface: Broadcaster
    
    Set the ID of this Broadcaster.
    
    Specified by:
    
    setID in interface Broadcaster
    
    Parameters:
    
    id - ID of this Broadcaster
  - rename
```
public Broadcaster rename(java.lang.String id)
```
    Rename this Broadcaster without invoking it's associated BroadcasterFactory. This method must be carefully used as it could easily create memory leak as the Broadcaster won't be removed from its BroadcasterFactory.
    
    Parameters:
    
    id - the new name
    
    Returns:
    
    this;
  - getID
```
public java.lang.String getID()
```
    Description copied from interface: Broadcaster
    
    Return the ID of this Broadcaster.
    
    Specified by:
    
    getID in interface Broadcaster
    
    Returns:
    
    the ID of this Broadcaster
  - resumeAll
```
public void resumeAll()
```
    Description copied from interface: Broadcaster
    
    Resume all suspended responses (AtmosphereResource) added via Broadcaster.addAtmosphereResource(org.atmosphere.cpr.AtmosphereResource).
    
    Specified by:
    
    resumeAll in interface Broadcaster
  - releaseExternalResources
```
public void releaseExternalResources()
```
    Description copied from interface: Broadcaster
    
    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)
```
    Description copied from interface: Broadcaster
    
    Set the BroadcasterLifeCyclePolicy. Make sure you are selecting the right policy to avoid unexpected situations.
    
    Specified by:
    
    setBroadcasterLifeCyclePolicy in interface Broadcaster
    
    Parameters:
    
    lifeCyclePolicy - a BroadcasterLifeCyclePolicy
  - getBroadcasterLifeCyclePolicy
```
public BroadcasterLifeCyclePolicy getBroadcasterLifeCyclePolicy()
```
    Description copied from interface: Broadcaster
    
    Get the BroadcasterLifeCyclePolicy.
    
    Specified by:
    
    getBroadcasterLifeCyclePolicy in interface Broadcaster
    
    Returns:
    
    BroadcasterLifeCyclePolicy
  - addBroadcasterLifeCyclePolicyListener
```
public void addBroadcasterLifeCyclePolicyListener(BroadcasterLifeCyclePolicyListener b)
```
    Description copied from interface: Broadcaster
    
    Add a BroadcasterLifeCyclePolicyListener.
    
    Specified by:
    
    addBroadcasterLifeCyclePolicyListener in interface Broadcaster
    
    Parameters:
    
    b - a BroadcasterLifeCyclePolicyListener
  - removeBroadcasterLifeCyclePolicyListener
```
public void removeBroadcasterLifeCyclePolicyListener(BroadcasterLifeCyclePolicyListener b)
```
    Description copied from interface: Broadcaster
    
    Remove a BroadcasterLifeCyclePolicyListener.
    
    Specified by:
    
    removeBroadcasterLifeCyclePolicyListener in interface Broadcaster
    
    Parameters:
    
    b - a BroadcasterLifeCyclePolicyListener
  - isDestroyed
```
public boolean isDestroyed()
```
    Description copied from interface: Broadcaster
    
    Return true if this Broadcaster has been destroyed.
    
    Specified by:
    
    isDestroyed in interface Broadcaster
    
    Returns:
    
    true if this Broadcaster has been destroyed
  - awaitAndBroadcast
```
public java.util.concurrent.Future<java.lang.Object> awaitAndBroadcast(java.lang.Object t,
                                                                       long time,
                                                                       java.util.concurrent.TimeUnit timeUnit)
```
    Description copied from interface: Broadcaster
    
    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)
```
    Description copied from interface: Broadcaster
    
    Add a BroadcasterListener.
    
    Specified by:
    
    addBroadcasterListener in interface Broadcaster
    
    Parameters:
    
    b - a BroadcasterListener
    
    Returns:
    
    this
  - removeBroadcasterListener
```
public Broadcaster removeBroadcasterListener(BroadcasterListener b)
```
    Description copied from interface: Broadcaster
    
    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(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.
    
    Returns:
    
    the default number of reactive threads
  - push
```
protected void push(Deliver deliver)
```
  - deliverPush
```
protected void deliverPush(Deliver deliver,
                           boolean rec)
```
  - endBroadcast
```
protected boolean endBroadcast(Deliver deliver,
                               AtmosphereResource r,
                               CacheMessage cacheMsg,
                               boolean deliverMessage)
```
  - queueWriteIO
```
protected void queueWriteIO(AtmosphereResource r,
                            Deliver deliver,
                            java.util.concurrent.atomic.AtomicInteger count)
                     throws java.lang.InterruptedException
```
    Throws:
    
    java.lang.InterruptedException
  - executeBlockingWrite
```
protected void executeBlockingWrite(AtmosphereResource r,
                                    Deliver deliver,
                                    java.util.concurrent.atomic.AtomicInteger count)
                             throws java.lang.InterruptedException
```
    Throws:
    
    java.lang.InterruptedException
  - perRequestFilter
```
protected boolean perRequestFilter(AtmosphereResource r,
                                   Deliver msg)
```
  - executeAsyncWrite
```
protected void executeAsyncWrite(DefaultBroadcaster.AsyncWriteToken token)
```
  - cacheMessageOnIOException
```
protected boolean cacheMessageOnIOException(java.lang.Throwable cause)
```
  - checkCachedAndPush
```
protected boolean checkCachedAndPush(AtmosphereResource r,
                                     AtmosphereResourceEvent e)
```
  - retrieveTrackedBroadcast
```
protected boolean retrieveTrackedBroadcast(AtmosphereResource r,
                                           AtmosphereResourceEvent e)
```
  - 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,
                             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)
```
    Description copied from interface: Broadcaster
    
    Set the maximum number of suspended AtmosphereResources. If the maximum 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 unlimited.
    
    Specified by:
    
    setSuspendPolicy in interface Broadcaster
    
    Parameters:
    
    maxSuspendResource - maximum number of suspended AtmosphereResource
  - broadcast
```
public java.util.concurrent.Future<java.lang.Object> broadcast(java.lang.Object msg)
```
    Description copied from interface: Broadcaster
    
    Broadcast the Object to all suspended responses, eg. invoke AtmosphereHandler.onStateChange(org.atmosphere.cpr.AtmosphereResourceEvent).
    
    Specified by:
    
    broadcast in interface Broadcaster
    
    Parameters:
    
    msg - the 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(Deliver e)
```
  - filter
```
protected java.lang.Object filter(java.lang.Object msg)
```
    Invoke the BroadcastFilter
    
    Parameters:
    
    msg -
    
    Returns:
  - broadcast
```
public java.util.concurrent.Future<java.lang.Object> broadcast(java.lang.Object msg,
                                                               AtmosphereResource r)
```
    Description copied from interface: Broadcaster
    
    Broadcast the Object to all suspended responses, eg. 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 - the Object to be broadcasted
    
    r - an AtmosphereResource
    
    Returns:
    
    a Future that can be used to synchronize using the Future.get()
  - broadcastOnResume
```
public java.util.concurrent.Future<java.lang.Object> broadcastOnResume(java.lang.Object msg)
```
    Description copied from interface: Broadcaster
    
    Broadcast the Object when an AtmosphereResource is resumed by a timeout or when using AtmosphereResource.resume().
    
    Specified by:
    
    broadcastOnResume in interface Broadcaster
    
    Parameters:
    
    msg - the 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 java.util.concurrent.Future<java.lang.Object> broadcast(java.lang.Object msg,
                                                               java.util.Set<AtmosphereResource> subset)
```
    Description copied from interface: Broadcaster
    
    Broadcast the Object to all suspended response, eg. 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 - the 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)
```
    Description copied from interface: Broadcaster
    
    Add a AtmosphereResource to the list of items to be notified when the Broadcaster.broadcast(java.lang.Object) 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 if there are messages available, and take the appropriate actions.
    
    Parameters:
    
    r - AtmosphereResource
  - notifyAndAdd
```
protected void notifyAndAdd(AtmosphereResource r)
```
  - entryDone
```
protected void entryDone(BroadcasterFuture<?> f)
```
  - notifyBroadcastListener
```
protected void notifyBroadcastListener()
```
  - notifyOnAddAtmosphereResourceListener
```
protected void notifyOnAddAtmosphereResourceListener(AtmosphereResource r)
```
  - notifyOnRemoveAtmosphereResourceListener
```
protected void notifyOnRemoveAtmosphereResourceListener(AtmosphereResource r)
```
  - notifyOnMessage
```
protected void notifyOnMessage(Deliver deliver)
```
  - removeAtmosphereResource
```
public Broadcaster removeAtmosphereResource(AtmosphereResource r)
```
    Description copied from interface: Broadcaster
    
    Remove a AtmosphereResource from the list of s to be notified when the Broadcaster.broadcast(java.lang.Object) 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)
```
    Description copied from interface: Broadcaster
    
    Set the BroadcasterConfig instance.
    
    Specified by:
    
    setBroadcasterConfig in interface Broadcaster
    
    Parameters:
    
    bc - Configuration to be set.
  - getBroadcasterConfig
```
public BroadcasterConfig getBroadcasterConfig()
```
    Description copied from interface: Broadcaster
    
    Return the current BroadcasterConfig.
    
    Specified by:
    
    getBroadcasterConfig in interface Broadcaster
    
    Returns:
    
    the current BroadcasterConfig
  - delayBroadcast
```
public java.util.concurrent.Future<java.lang.Object> delayBroadcast(java.lang.Object o)
```
    Description copied from interface: Broadcaster
    
    Delay the broadcast operation. The Object will be broadcasted when Broadcaster.broadcast(java.lang.Object) is invoked the first time.
    
    Specified by:
    
    delayBroadcast in interface Broadcaster
    
    Parameters:
    
    o - the Object to be broadcasted
    
    Returns:
    
    a Future that can be used to synchronize using the Future.get()
  - delayBroadcast
```
public java.util.concurrent.Future<java.lang.Object> delayBroadcast(java.lang.Object o,
                                                                    long delay,
                                                                    java.util.concurrent.TimeUnit t)
```
    Description copied from interface: Broadcaster
    
    Delay the broadcast operation. The Object will be broadcasted once the specified delay expires or when Broadcaster.broadcast(java.lang.Object) is invoked the first time.
    
    Specified by:
    
    delayBroadcast in interface Broadcaster
    
    Parameters:
    
    o - the Object to be broadcasted
    
    delay - Amount of time to delay
    
    t - the TimeUnit of the delay
    
    Returns:
    
    a Future that can be used to synchronize using the Future.get()
  - scheduleFixedBroadcast
```
public java.util.concurrent.Future<java.lang.Object> scheduleFixedBroadcast(java.lang.Object o,
                                                                            long period,
                                                                            java.util.concurrent.TimeUnit t)
```
    Description copied from interface: Broadcaster
    
    Broadcast periodically. The Object will be broadcasted after every period specified time frame expires. If the TimeUnit is set to null, the Object will be broadcasted when the first Broadcaster.broadcast(java.lang.Object) is invoked.
    
    Specified by:
    
    scheduleFixedBroadcast in interface Broadcaster
    
    Parameters:
    
    o - the 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<java.lang.Object> scheduleFixedBroadcast(java.lang.Object o,
                                                                            long waitFor,
                                                                            long period,
                                                                            java.util.concurrent.TimeUnit t)
```
    Description copied from interface: Broadcaster
    
    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 - the 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
  - broadcasterListeners
```
public java.util.Collection<BroadcasterListener> broadcasterListeners()
```
  - lifeCyclePolicy
```
public BroadcasterLifeCyclePolicy lifeCyclePolicy()
```
  - lifeCycleListeners
```
public java.util.concurrent.ConcurrentLinkedQueue<BroadcasterLifeCyclePolicyListener> lifeCycleListeners()
```
  - messages
```
public java.util.concurrent.BlockingQueue<Deliver> messages()
```
  - writeQueues
```
public java.util.concurrent.ConcurrentHashMap<java.lang.String,DefaultBroadcaster.WriteQueue> writeQueues()
```
  - policy
```
public Broadcaster.POLICY policy()
```
  - outOfOrderBroadcastSupported
```
public boolean outOfOrderBroadcastSupported()
```
  - recentActivity
```
public java.util.concurrent.atomic.AtomicBoolean recentActivity()
```
  - lifecycleHandler
```
public LifecycleHandler lifecycleHandler()
```
  - lifecycleHandler
```
public DefaultBroadcaster lifecycleHandler(LifecycleHandler lifecycleHandler)
```
  - currentLifecycleTask
```
public java.util.concurrent.Future<?> currentLifecycleTask()
```
  - currentLifecycleTask
```
public DefaultBroadcaster currentLifecycleTask(java.util.concurrent.Future<?> currentLifecycleTask)
```

Modifier and Type	Class	Description
`protected static class`	`DefaultBroadcaster.AsyncWriteToken`
`static class`	`DefaultBroadcaster.WriteQueue`

Class DefaultBroadcaster

Nested Class Summary

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

Field Summary

Fields inherited from interface org.atmosphere.cpr.Broadcaster

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

POLLING_DEFAULT

CACHED

resources

bc

messages

broadcasterListeners

started

initialized

destroyed

scope

name

delayedBroadcast

broadcastOnResume

lifeCycleListeners

writeQueues

uniqueWriteQueue

dispatchThread

notifierFuture

asyncWriteFuture

uri

config

writeTimeoutInSecond

waitTime

sharedListeners

candidateForPoolable

usingTokenIdForAttribute

Constructor Detail

DefaultBroadcaster

Method Detail

initialize

initialize

createBroadcasterConfig

destroy

getAtmosphereResources

setScope

getScope

setID

rename

getID

resumeAll

releaseExternalResources

setBroadcasterLifeCyclePolicy

getBroadcasterLifeCyclePolicy

addBroadcasterLifeCyclePolicyListener

removeBroadcasterLifeCyclePolicyListener

isDestroyed

awaitAndBroadcast

addBroadcasterListener

removeBroadcasterListener

getBroadcastHandler

getAsyncWriteHandler

start

spawnReactor

killReactiveThreads

reactiveThreadsCount

push

deliverPush

endBroadcast

queueWriteIO

executeBlockingWrite

perRequestFilter

executeAsyncWrite

cacheMessageOnIOException

checkCachedAndPush

retrieveTrackedBroadcast

invokeOnStateChange

prepareInvokeOnStateChange

onException

onException

cacheLostMessage

cacheLostMessage