ThreadExecutorExample

Executor.java

/**
 * @author Jc Miñarro
 */
public interface Executor<T extends Runnable> {

	void run(final T interactor);
}

MainThread

/**
 * @author Jc Miñarro
 */
public interface MainThread {

	void post(final Runnable runnable);
}

MainThreadImpl.java

import android.os.Handler;
import android.os.Looper;

/**
 * @author Jc Miñarro
 */
public class MainThreadImpl implements MainThread {

	private final Handler handler;

	public MainThreadImpl() {
		handler = new Handler(Looper.getMainLooper());
	}

	@Override
	public void post(Runnable runnable) {
		handler.post(runnable);
	}

ThreadExecutor.java

import java.util.Comparator;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * Executor implementation based on ThreadPoolExecutor. ThreadPoolExecutorConfig:
 *
 * Core pool size: 3.
 * Max pool size: 5.
 * Keep alive time: 120.
 * Time unit: seconds.
 * Work queue: LinkedBlockingQueue.
 *
 * @author Jc Miñarro
 */
public class ThreadExecutor implements Executor<ThreadExecutor.PriorityRunnable> {

	private static final int CORE_POOL_SIZE = 3;
	private static final int MAX_POOL_SIZE = 5;
	private static final int KEEP_ALIVE_TIME = 120;
	private static final TimeUnit TIME_UNIT = TimeUnit.SECONDS;

	private ThreadPoolExecutor threadPoolExecutor;

	public ThreadExecutor() {
		int corePoolSize = CORE_POOL_SIZE;
		int maxPoolSize = MAX_POOL_SIZE;
		int keepAliveTime = KEEP_ALIVE_TIME;
		TimeUnit timeUnit = TIME_UNIT;
		BlockingQueue workQueue = new PriorityBlockingQueue<PriorityRunnable>(corePoolSize, new Comparator<PriorityRunnable>() {
			@Override
			public int compare(PriorityRunnable lhs, PriorityRunnable rhs) {
				return rhs.getPriority().compareTo(lhs.getPriority());
			}
		});
		threadPoolExecutor =
				new ThreadPoolExecutor(corePoolSize, maxPoolSize, keepAliveTime, timeUnit, workQueue);
	}

	@Override
	public void run(final PriorityRunnable interactor) {
		if (interactor == null) {
			throw new IllegalArgumentException("Interactor to execute can't be null");
		}
		threadPoolExecutor.execute(interactor);
	}

	public interface PriorityRunnable extends Runnable {

		public enum Priority {
			LOW,
			HI
		}

		public Priority getPriority();

	}

}

ThreadFacade.java

/**
 * @author Jc Miñarro
 */
public class ThreadFacade {

	private final MainThread mainThread;

	private final Executor executor;

	public ThreadFacade(MainThread mainThread, Executor executor) {
		this.mainThread = mainThread;
		this.executor = executor;
	}

	public void postOnBackgroundWithHiPriority(Runnable runnable) {
		this.executor.run(new HiPriorityRunnable(runnable));
	}

	public void postOnBackgroundWithLowPriority(Runnable runnable) {
		this.executor.run(new LowPriorityRunnable(runnable));
	}

	public void postOnMainThread(Runnable runnable) {
		this.mainThread.post(runnable);
	}

	private abstract class PriorityRunnableAbs implements ThreadExecutor.PriorityRunnable {

		protected final Runnable runnable;

		public PriorityRunnableAbs(Runnable runnable) {
			this.runnable = runnable;
		}

		@Override
		public void run() {
			this.runnable.run();
		}
	}

	private class HiPriorityRunnable extends PriorityRunnableAbs{

		public HiPriorityRunnable(Runnable runnable) {
			super(runnable);
		}

		@Override
		public Priority getPriority() {
			return Priority.HI;
		}
	}

	private class LowPriorityRunnable extends PriorityRunnableAbs{

		public LowPriorityRunnable(Runnable runnable) {
			super(runnable);
		}

		@Override
		public Priority getPriority() {
			return Priority.LOW;
		}
	}

}