[SWING] Join thread with SwingWorker objects

Hi guys!

May you give me any suggestion for the following?

I have a method (issued by an actionPerformed) that instantiate a
SchedulerTask object (a SwingWorker object) and call execute() method
on it.
This execute() method instantiate N SingleTasks and call the execute()
method on them.

Now, I'd like the SchedulerTask to finish its job and return
(executing the overriden done() method inherited by SwingWorker class)
only when all N SingleTasks have completed their work. Currently, I
have that SchedulerTask finishes its work after launched the N
SingleTask(s) without waiting for their completetion.

I've tried to insert a while(finishedProcesses<N) do nothing cycle but
the GUI had dramatical issues in responsiveness and performances.

Have you ever dealt with this kind of stuff in Swing?

Below, some code (it's not consistent...only to give an idea of what I
mean..hope that it'll be useful):

 private void startBatchBtnActionPerformed(java.awt.event.ActionEvent
evt) {
        SchedulerTask scheduler = new SchedulerTask(batchItemsList);
        scheduler.execute();
    }

////////////////////////////////////////////////////////////////////////////////

class SchedulerTask extends SwingWorker<Integer, Void> implements
ActionListener {
    private List<BatchExtractionItem> items;

    private Timer timer;
    int lastIndex;
    int activeProcesses;

    private final static int MAX_ACTIVE_PROCESSES = 5;

    private List<BatchExtractionItem> currentProcesses = new
ArrayList<BatchExtractionItem>(MAX_ACTIVE_PROCESSES);

    public SchedulerTask(List<BatchExtractionItem> items) {
        this.items = items;

        this.timer = new Timer(1000, this);
        this.timer.start();

    }

    public void processCompleted(BatchExtractionItem completedItem) {
        //System.out.println("Completed "+completedItem);

        activeProcesses--;

    }

    @Override
    protected Integer doInBackground() throws Exception {
        lastIndex = 0;
        activeProcesses = 0;
        while (lastIndex<items.size()) {
            while(lastIndex<items.size() &&
activeProcesses<MAX_ACTIVE_PROCESSES) {
                currentProcesses.add(this.items.get(lastIndex));
                lastIndex++;
                activeProcesses++;
            }

            for (BatchExtractionItem item: currentProcesses) {
                if (!item.getStatus().equals
(BatchExtractionItem.COMPLETED) && !item.getStatus().equals
(BatchExtractionItem.PROCESSING)) {
                    item.setStatus(BatchExtractionItem.PROCESSING);
                    BatchTask task = new BatchTask(item);
                    task.execute();
                }
            }
        }
        while (activeProcesses>0) {
            //do nothing...waiting...
        }
        return 0;
    }

    @Override
    protected void done() {
        //popup to inform the user that batch extraction is finished
        //System.out.println("completed batch");

        this.timer.stop();
        form.getProgressBar().setValue(100);

    }

    @Override
    public void actionPerformed(ActionEvent e) {
//issued by Timer event

        int completed = countCompleted();
        int progress = completed/items.size();
        setProgress(progress);
        form.getProgressBar().setValue(progress);
    }

    private int countCompleted() {
        int c=0;
        for (BatchExtractionItem i: items) {
            if (i.getStatus().equals(BatchExtractionItem.COMPLETED)) {
                c++;
            }
        }
        return c;
    }

}

///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
class BatchTask extends SwingWorker<List<SampledValue>, Void> {
    BatchExtractionItem item;

    SchedulerTask scheduler;
    Timer timer;

    public BatchTask(BatchExtractionItem item, Batcher batcher,
SchedulerTask scheduler) {
        this.item = item;
       this.batcher = batcher;
        this.scheduler = scheduler;

    }

    @Override
    protected List<SampledValue> doInBackground() throws Exception {
        String guid = UUID.randomUUID().toString();
        List<SampledValue> results = this.batcher.batchItemExtract
(item, guid);
        return results;
    }

    @Override
    protected void done() {
        //save results
        scheduler.processCompleted(this.item);
        List<SampledValue> resultList;
            try {
                resultList = get();
                //print result List somewhere

            }
            catch (InterruptedException ignore) {
            } catch (ExecutionException e) {
                String why = null;
                Throwable cause = e.getCause();
                if (cause != null) {
                    why = cause.getMessage();
                } else {
                    why = e.getMessage();
                }
                System.err.println("Error: " + why);
            }
    }