多线程的等待和通知问题

Question

I am having a problem with the methods wait() and notify() . I have three threads, one is called Management (which is responsible for managing the others threads) and two called Worker , both classes implement Runnable . The Management submit one task for each Worker and keep working. The Worker , when recieve a task needs to process the task and wait for other task.

In my Management , I have a method called doWork , that basically send the tasks to the Workers and notify them. All implementation is described below:

WorkerManagement (please, consider constructor and others methods implemented):

public class WorkerManagement extends ActiveObject{
    private volatile Map<Worker, Boolean> workers = new HashMap<>();
    @Override
    protected void doWork() {
        while(!mustStop()){
            if(getAvailableThreadsSize() != workers.size()){
                continue;
            }
            WorkQueue highestPriorityWorkQueue = workQueues.getHighestPriorityWorkQueue();
            if(highestPriorityWorkQueue == null){
                continue;
            }
            tasks = highestPriorityWorkQueue.pollList();
            for (Map.Entry<Worker, Boolean> entry : workers.entrySet()) {
                Worker worker = entry.getKey();
                worker.updateTask(tasks.poll());
                workers.replace(worker, Boolean.FALSE);
                synchronized (worker) {
                    worker.notify();
                }
            }
        }
    }
    private int getAvailableThreadsSize(){
        int availables = 0;
        for (Map.Entry<Worker, Boolean> entry : workers.entrySet()) {
            Boolean available = entry.getValue();
            if(available){
                availables++;
            }
        }
        return availables;
    }
}

Worker (please, consider constructor and others methods implemented):

public class Worker extends ActiveObject{
    private WorkerManagement workerManagement;
    private Task task;

    @Override
    protected void doWork() {
        while (!mustStop()) {
            System.out.println(Thread.currentThread().getName()+" is Alive:"+Thread.currentThread().isAlive());
            try {
                task.execute();

                workerManagement.setAvailable(this);

                synchronized(this){
                    System.out.println(Thread.currentThread().getName()+" is Alive:"+Thread.currentThread().isAlive());
                    wait();
                }
            } catch (Exception ex) {
                LOGGER.log(Level.SEVERE, "Exception in Worker: " + getName(), ex);
            }
            
        }
    }

}

PS: ActiveObject is an inner class that implements Runnable .

@EDIT: My problem, basically is: One worker is always waiting and the other is always alive. So, when I debug the code on WorkerManagement the method getAvailableThreadsSize is always returning 1 and the workers.size() is returning 2. An example of output of my doWork print's is:

WorkerThread-1 is Alive:true
WorkerThread-2 is Alive:true
WorkerThread-2 is Alive:true
WorkerThread-2 is Alive:true
WorkerThread-2 is Alive:true

Which means that the WorkerThread-2 is always working while WorkerThread-1 is waiting (except the first execution).

Answer 1

Whit this code

if (getAvailableThreadsSize() != workers.size()){
    continue;
}

if these is a thread running the number of available threads will be workers.size()-1 so only one thread can be activate

try to change to

if (getAvailableThreadsSize() >0){
    continue;
}

Answer 2

Actually the problem was becaus the task was null and it threw erros before entering on the synchronized block. I fixed it adding and verification on the beggining of the while:

if(workUnitToProcess == null){
    synchronized (this) {
        workerManagement.setAvailable(this);
        wait();
    }
}