Запуск большого количества потоков с возвращением результ

int b;
private void someMethod(int a){
  b >  10 ? b+=a : b-=a;
}

import java.util.Random;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CopyOnWriteArrayList;

public class GeneralMan {

	private int maxJob;
	public static Random cuRand;
	public GeneralMan(int pMaxJob) {
		maxJob = pMaxJob;
		cuRand = new Random();
	}

	public void MainProccess() throws InterruptedException {
		TaskTicket cuTT = getNewTT();
		while (cuTT != null) {
			JoberMan cuJober = getJober();

			cuJober.addGetTaskTicket(cuTT);

			if (!allJobers.contains(cuJober)) {
				allJobers.add(cuJober);
				Thread cuThe = new Thread(cuJober);
				allThe.add(cuThe);
				cuThe.start();
			}
			else
				synchronized(cuJober) { cuJober.notify(); }

			cuTT = getNewTT();
		}
		System.out.println("Max free jober: " + maxFree);
		System.out.println("countJob: " + JoberMan.countJob);

		// проверочная часть. Здесь нужно отлавливать сбойные задания и убивать подвисших jober'ов
		Thread.sleep(Main.PauseMaxJob * 10);
		for(JoberMan aJober : allJobers) {
			aJober.isStop = true;
			synchronized(aJober) { aJober.notify(); }
		}
		Thread.sleep(Main.PauseMaxJob * 10);

		for(Thread aThe : allThe) {
			if (aThe.isAlive())
				System.out.println("Кто-то до сих пор работает!");
		}
	}

	private JoberMan getJober() {
		JoberMan cuJober = addGetFreeJober(null);

		if (cuJober == null) { // свободных нет, создаем или добавляем задания
			if (allJobers.size() < maxJob) {
				cuJober = new JoberMan(genJoberListener);
			}
			else {
				synchronized(cuRand) {
					// выбираем случайным образом потому что неизвестно кто хорошо справляется
					cuJober = allJobers.get(cuRand.nextInt(allJobers.size()));
					// подумать а если другой поток захватит allJobers и потом cuRand ;)
				}
			}
		}

		return cuJober;
	}

	private static int maxTT;
	private TaskTicket getNewTT() {

		if (maxTT > maxJob*2) return null; // искуственный признак окончания

		TaskTicket cuTT = new TaskTicket(); // стоит сохранять в списке, чтобы потом проверить - успешно ли выполнено. см StateJobTicket

		cuTT.dataTask = String.valueOf(maxTT++); // просто строка с номером задания, а не реальные данные
		try {
			Thread.sleep(Main.PauseNewTask); // затраты времени на формирование задания
		} catch (InterruptedException ex) {
			//Logger.getLogger(GeneralMan.class.getName()).log(Level.SEVERE, null, ex);
		}

		return cuTT;
	}

	ConcurrentLinkedQueue<Thread> allThe = new ConcurrentLinkedQueue<Thread>(); // список всех потоков
	CopyOnWriteArrayList<JoberMan> allJobers = new CopyOnWriteArrayList<JoberMan>(); // список всех джоберов
	ConcurrentLinkedQueue<JoberMan> freeJobers = new ConcurrentLinkedQueue<JoberMan>(); // список простаивающих

	public int maxFree; // для сбора статистики

	JoberMan addGetFreeJober(JoberMan pFree) {
		JoberMan resultJ = pFree;

			if (pFree == null) {
				Thread.yield(); // даем возможность кому-то из джоберов закончить выполнение задания 
				resultJ = freeJobers.poll();
			}
			else {
				if (!freeJobers.contains(pFree))
					freeJobers.add(pFree);

				if (maxFree < freeJobers.size()) // для сбора максимального количества простаивающих
                  // и в этот момент вызвался freeJobers.poll() - что будет? и в каких еще местах возможна такая ситуация? ;)
					maxFree = freeJobers.size();
		}
		return resultJ;
	}

	void delJober(JoberMan pFree) {
			allJobers.remove(pFree);
	}

	private ReceiveMess genJoberListener = new ReceiveMess();
	private class ReceiveMess implements ListenerJob {

		public void Ifree(JoberMan pObj) {
			GeneralMan.this.addGetFreeJober(pObj);
		}

		public void Idead(JoberMan pObj) {
			GeneralMan.this.delJober(pObj);
		}

	}
}

import java.util.concurrent.ConcurrentLinkedQueue;

public class JoberMan implements Runnable {

	public static int countJob;
	public int IDjober;

	private ListenerJob cuListe;
	public JoberMan (ListenerJob pListener) {
		cuListe = pListener;
		IDjober = countJob++;
	}

	ConcurrentLinkedQueue<TaskTicket> lstTT = new ConcurrentLinkedQueue<TaskTicket>();
	public TaskTicket addGetTaskTicket(TaskTicket pTT) {

		TaskTicket resultOp = pTT;
		
		if (pTT == null)
				resultOp = lstTT.poll();
		else
			lstTT.add(pTT);

		return resultOp;
	}

	public Exception isEx; // ошибка выполения, для анализа в GeneralMan

	public volatile boolean isStop;
	public void run() {
		TaskTicket cuTT = addGetTaskTicket(null);
		
		ENDRUN:
		while (cuTT != null) {
			try {
				procTT(cuTT);

				cuTT = addGetTaskTicket(null);
				while (cuTT == null) { // Always wait inside a loop that checks the condition being 
        // waited on – this addresses the timing issue if another 
        // thread satisfes the condition before the wait begins.  
        // Also, it protects your code from spurious wake-ups that 
        // can (and do) occur.
					if (isStop) break ENDRUN;

					synchronized(this) {
						cuListe.Ifree(this);
						this.wait();
					}
					
					cuTT = addGetTaskTicket(null);
				}

			} catch (InterruptedException ex) {
				isEx = ex;
				//Logger.getLogger(JoberMan.class.getName()).log(Level.SEVERE, null, ex);
			}
		}
		isStop = true;
		cuListe.Idead(this);
	}

	private boolean procTT(TaskTicket cuTT) throws InterruptedException {

		cuTT.stampTask = StateJobTicket.Working;

		int rndInt = 0;
		synchronized(GeneralMan.cuRand) {
			rndInt = GeneralMan.cuRand.nextInt(Main.PauseMaxJob);
		}

		if (rndInt < 5) { // генерируем ошибку выполения задания шоб жизнь малиной не казалась
			System.out.println(String.valueOf(IDjober) + " Error " + cuTT.dataTask);
			cuTT.stampTask = StateJobTicket.Error;
			cuTT.errorInfo = String.valueOf(IDjober) + String.valueOf(rndInt);
		}
		else {
			System.out.println(String.valueOf(IDjober) + " task: " + cuTT.dataTask);

			Thread.sleep(rndInt); // типа работаем

			cuTT.stampTask = StateJobTicket.Sucess;
		}

		return cuTT.stampTask == StateJobTicket.Sucess;
	}

}

public enum StateJobTicket {
	Start,
	Working,
	Sucess,
	Error
}

public interface ListenerJob {
	void Ifree(JoberMan pObj);
	void Idead(JoberMan pObj);
}

public class Main {

	// для тестов
	public static int MaxTheard = 500; // максимально допустимое количество потоков
	public static int PauseNewTask = 1; // миллисекунд для формирования задания
	public static int PauseMaxJob = 100; // максимум миллисекунд для выполнения задания

	/**
	 * @param args the command line arguments
	 */
	public static void main(String[] args) {
		GeneralMan cuGMan = new GeneralMan(MaxTheard);
		try {
			cuGMan.MainProccess();
		} catch (InterruptedException ex) {
			//Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
		}
	}
}