EventManagerImp.java

package org.act.tstream.event;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;

import org.act.tstream.callback.RunnableCallback;

import backtype.storm.utils.Time;

/**
 * Event Manager, drop one event from queue, then execute the event.
 */
public class EventManagerImp implements EventManager {
	private AtomicInteger added = new AtomicInteger();
	private AtomicInteger processed = new AtomicInteger();
	private AtomicBoolean isrunning = new AtomicBoolean(true);
	private Thread runningThread;
	private LinkedBlockingQueue<RunnableCallback> queue = new LinkedBlockingQueue<RunnableCallback>();

	public EventManagerImp(boolean _daemon) {

		Runnable runner = new EventManagerImpExecute(this);

		this.runningThread = new Thread(runner);
		this.runningThread.setDaemon(_daemon);
		this.runningThread.start();
	}

	public boolean isRunning() {
		return isrunning.get();
	}

	public RunnableCallback poll() throws InterruptedException {
		RunnableCallback event = queue.poll();
		return event;
	}
	
	public RunnableCallback take() throws InterruptedException {
		RunnableCallback event = queue.take();
		return event;
	}

	public void proccessinc() {
		processed.incrementAndGet();
	}

	@Override
	public void add(RunnableCallback event_fn) {
		if (!this.isRunning()) {
			// throw new RuntimeException(
			// "Cannot add events to a shutdown event manager");

			return;
		}
		added.incrementAndGet();
		queue.add(event_fn);
	}

	@Override
	public boolean waiting() {
		return (processed.get() == added.get());

		// return Time.isThreadWaiting(runningThread) ||
		// (processed.get() == added.get());

	}

	@Override
	public void shutdown() {
		isrunning.set(false);
		runningThread.interrupt();
		try {
			runningThread.join();
		} catch (InterruptedException e) {
		}

	}
}