MyConcurrService

public class MyConcurrService<T> {


public MyConcurrService(CallbackListener<T> resultListener) {
this(resultListener, 2, 10, "general");
}


public MyConcurrService(CallbackListener<T> resultListener,
int threadFactor, int queueSizeFactor, String taskInfo) {


int threads = threadFactor;
int queueSize = queueSizeFactor;
takQueue = (queueSize > 0) ? new ArrayBlockingQueue<Callable<T>>(
queueSize) : new LinkedBlockingQueue<Callable<T>>();


threadFactory = new MyThreadFactory(taskInfo);


service = Executors.newFixedThreadPool(threads, threadFactory);


resultQ = (queueSize > 0) ? new ArrayBlockingQueue<Future<T>>(
queueSize) : new LinkedBlockingQueue<Future<T>>();
this.resultLsn = resultListener;
}


public void start() {
canceled.set(false);
if (accInput.get()) {
throw new IllegalStateException("Service is already running");
}
synchronized (accLock) {
takServiceStatus = takService.submit(new Callable<Void>() {
public Void call() throws Exception {
Callable<T> task;
try {
while (!canceled.get()) {
task = takQueue.take();
if (task == endTask) {
resultQ.put(endResult);
break;
}
Future<T> result = service.submit(task);
resultQ.put(result);
}
} catch (Exception e) {
throw e;
}
return null;
}
});


resultServiceStatus = resultSvc.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
while (!canceled.get()) {
Future<T> resultFuture = resultQ.take();
if (resultFuture == endResult) {
break;
}
T result = resultFuture.get();
resultLsn.accept(result);
}
resultLsn.close();
} catch (Exception e) {
takServiceStatus.cancel(true);
service.shutdownNow();
throw e;
}
return null;
}
});


accInput.set(true);
}
}


public void stopAndWait() throws InterruptedException, ExecutionException {
synchronized (accLock) {
if (!accInput.get()) {
throw new IllegalStateException("Service is not running");
}
submit(endTask);
accInput.set(false);
}


takServiceStatus.get();
resultServiceStatus.get();
takService.shutdown();
service.shutdown();
resultSvc.shutdown();
}


public void submit(Callable<T> task) throws InterruptedException {
if (!accInput.get()) {
throw new IllegalStateException("Service is not running");
}
takQueue.put(task);
}


public void cancel() {
accInput.set(false);
canceled.set(true);
}


private final Callable<T> endTask = new Callable<T>() {
public T call() throws Exception {
return null;
}
};


private final Future<T> endResult = new FutureTask<T>(new Callable<T>() {
public T call() throws Exception {
return null;
}
});

private final BlockingQueue<Callable<T>> takQueue;
private final ExecutorService takService = Executors
.newSingleThreadExecutor();
private volatile Future<Void> takServiceStatus;
private final ExecutorService service;
private final BlockingQueue<Future<T>> resultQ;
private final ExecutorService resultSvc = Executors
.newSingleThreadExecutor();
private final CallbackListener<T> resultLsn;
private volatile Future<Void> resultServiceStatus;
private MyThreadFactory threadFactory;
private final AtomicBoolean canceled = new AtomicBoolean(false);
private final AtomicBoolean accInput = new AtomicBoolean(false);
private Object[] accLock = new Object[] {};


}