Package akka.dispatch

Class Mailbox

  • All Implemented Interfaces:
    SystemMessageQueue, java.io.Serializable, java.lang.Runnable, java.util.concurrent.Future<scala.runtime.BoxedUnit>
    Direct Known Subclasses:
    CallingThreadMailbox

    public abstract class Mailbox
    extends java.util.concurrent.ForkJoinTask<scala.runtime.BoxedUnit>
    implements SystemMessageQueue, java.lang.Runnable
    Mailbox and InternalMailbox is separated in two classes because ActorCell is needed for implementation, but can't be exposed to user defined mailbox subclasses.

    INTERNAL API

    See Also:
    Serialized Form
    • Constructor Detail

    • Method Detail

      • Open

        public static final int Open()
      • Closed

        public static final int Closed()
      • Scheduled

        public static final int Scheduled()
      • shouldScheduleMask

        public static final int shouldScheduleMask()
      • shouldNotProcessMask

        public static final int shouldNotProcessMask()
      • suspendMask

        public static final int suspendMask()
      • suspendUnit

        public static final int suspendUnit()
      • debug

        public static final boolean debug()
      • actor_$eq

        public void actor_$eq​(ActorCell x$1)
      • setActor

        public void setActor​(ActorCell cell)
      • enqueue

        public void enqueue​(ActorRef receiver,
                            Envelope msg)
        Try to enqueue the message to this queue, or throw an exception.
        Parameters:
        receiver - (undocumented)
        msg - (undocumented)
      • dequeue

        public Envelope dequeue()
        Try to dequeue the next message from this queue, return null failing that.
        Returns:
        (undocumented)
      • hasMessages

        public boolean hasMessages()
        Indicates whether this queue is non-empty.
        Returns:
        (undocumented)
      • numberOfMessages

        public int numberOfMessages()
        Should return the current number of messages held in this queue; may always return 0 if no other value is available efficiently. Do not use this for testing for presence of messages, use hasMessages instead.
        Returns:
        (undocumented)
      • _statusDoNotCallMeDirectly

        protected int _statusDoNotCallMeDirectly()
      • _statusDoNotCallMeDirectly_$eq

        protected void _statusDoNotCallMeDirectly_$eq​(int x$1)
      • _systemQueueDoNotCallMeDirectly

        protected SystemMessage _systemQueueDoNotCallMeDirectly()
      • _systemQueueDoNotCallMeDirectly_$eq

        protected void _systemQueueDoNotCallMeDirectly_$eq​(SystemMessage x$1)
      • currentStatus

        public final int currentStatus()
      • shouldProcessMessage

        public final boolean shouldProcessMessage()
      • suspendCount

        public final int suspendCount()
      • isSuspended

        public final boolean isSuspended()
      • isClosed

        public final boolean isClosed()
      • isScheduled

        public final boolean isScheduled()
      • updateStatus

        protected final boolean updateStatus​(int oldStatus,
                                             int newStatus)
      • setStatus

        protected final void setStatus​(int newStatus)
      • resume

        public final boolean resume()
        Reduce the suspend count by one. Caller does not need to worry about whether status was Scheduled or not.

        Returns:
        true if the suspend count reached zero
      • suspend

        public final boolean suspend()
        Increment the suspend count by one. Caller does not need to worry about whether status was Scheduled or not.

        Returns:
        true if the previous suspend count was zero
      • becomeClosed

        public final boolean becomeClosed()
        set new primary status Closed. Caller does not need to worry about whether status was Scheduled or not.
        Returns:
        (undocumented)
      • setAsScheduled

        public final boolean setAsScheduled()
        Set Scheduled status, keeping primary status as is.
        Returns:
        (undocumented)
      • setAsIdle

        public final boolean setAsIdle()
        Reset Scheduled status, keeping primary status as is.
        Returns:
        (undocumented)
      • canBeScheduledForExecution

        public final boolean canBeScheduledForExecution​(boolean hasMessageHint,
                                                        boolean hasSystemMessageHint)
      • run

        public final void run()
        Specified by:
        run in interface java.lang.Runnable
      • getRawResult

        public final void getRawResult()
      • setRawResult

        public final void setRawResult​(scala.runtime.BoxedUnit unit)
        Specified by:
        setRawResult in class java.util.concurrent.ForkJoinTask<scala.runtime.BoxedUnit>
      • exec

        public final boolean exec()
        Specified by:
        exec in class java.util.concurrent.ForkJoinTask<scala.runtime.BoxedUnit>
      • processAllSystemMessages

        public final void processAllSystemMessages()
        Will at least try to process all queued system messages: in case of failure simply drop and go on to the next, because there is nothing to restart here (failure is in ActorCell somewhere …). In case the mailbox becomes closed (because of processing a Terminate message), dump all already dequeued message to deadLetters.
      • cleanUp

        protected void cleanUp()
        Overridable callback to clean up the mailbox, called when an actor is unregistered. By default it dequeues all system messages + messages and ships them to the owning actors' systems' DeadLetterMailbox