/**
 * Created by rhightower on 2/10/15.
 */
public interface QueueCallBackHandler {

    /**
     * Queue has reached its limit, can be the same as batch size for queue.
     * This is for periodic flushing to IO or CPU intensive services to improve throughput.
     * Larger batches can equate to a lot less thread sync for the hand-off.
     */
    void queueLimit();

    /**
     * Notification that there is nothing else in the queue.
     */
    void queueEmpty();


    /** Callback for when the queue has started. */
    default void queueInit() {}

    /** Callback for when the queue is idle. */
    default void queueIdle() {}

    /** Callback for when the queue is shutdown. */
    default void queueShutdown(){}

    /** Callback for when the queue has just received some message.
     * idle can mean you are asleep with nothing to do.
     * startBatch can mean you just woke up.
     **/
    default void queueStartBatch() {}

}

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;


@Target({ ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
public @interface QueueCallback {

    /* The type of callback. */;
    QueueCallbackType value() default QueueCallbackType.DYNAMIC;

}

public class EventManagerImpl implements EventManager {

    @QueueCallback(QueueCallbackType.LIMIT)
    private void queueLimit() {



        if (messageCountSinceLastFlush > 100_000) {

            now = Timer.timer().now();
            sendMessages();
            return;
        }

        now = Timer.timer().now();
        long duration = now - lastFlushTime;

        if (duration > 50 && messageCountSinceLastFlush > 0) {
            sendMessages();
        }

    }



    @QueueCallback(QueueCallbackType.EMPTY)
    private void queueEmpty() {


        if (messageCountSinceLastFlush > 100) {

            now = Timer.timer().now();
            sendMessages();
            return;
        }



        now = Timer.timer().now();
        long duration = now - lastFlushTime;

        if (duration > 50 && messageCountSinceLastFlush > 0) {
            sendMessages();
        }

    }

public class StatService  implements QueueCallBackHandler {

    public void queueLimit() {
        now = Timer.timer().now();
        process();
    }

    public void queueEmpty() {
        now = Timer.timer().now();
        process();
    }

@RequestMapping("/myservice")
public class MyServiceQBit {


    void queueLimit() {
        ...
    }

    void queueEmpty() {
        ...
    }