package test;

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

class Executor {
    private JButton button;

    JButton getButton() {
        return button;
    }

    void setButton(JButton button) {
        this.button = button;
    }

    void task(int id) throws InterruptedException {
        Random random = new Random();
        int timer = random.nextInt(5);
        Thread.sleep(1000 * timer);
        System.out.println("Задача [" + id + "] выполнена: " + new Date());
    }

    void run() throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(8);
        List<Future> futureList = new ArrayList<Future>();

        System.out.println("Кнопка не активна");
        button.setEnabled(false);
        for (int x = 0; x < 10; x++) {
            final int id = x;
            futureList.add(executorService.submit(new Runnable() {
                public void run() {
                    try {
                        task(id);
                    } catch (Throwable e) {
                        e.printStackTrace();
                    }
                }
            }));
        }
        executorService.shutdown();
        executorService.awaitTermination(10, TimeUnit.HOURS);
        System.out.println("Кнопка активна");
        button.setEnabled(true);
    }
}

public class TestButtonEnabled extends JFrame {
    private JButton getButton() {
        JButton button = new JButton("test");
        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    Executor executor = new Executor();
                    executor.setButton(button);
                    executor.run();
                } catch (InterruptedException e1) {
                    e1.printStackTrace();
                }
            }
        });
        return button;
    }

    private static void createAndShowGui() {
        TestButtonEnabled testButtonEnabled = new TestButtonEnabled();
        JFrame frame = new JFrame("Test");
        frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        frame.add(testButtonEnabled.getButton());
        frame.pack();
        frame.setLocationByPlatform(true);
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                createAndShowGui();
            }
        });
    }
}

        executorService.shutdown();
        executorService.awaitTermination(10, TimeUnit.HOURS);

for (Future f : futureList){
      f.get();         
}

package test;

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.util.Random;

class Counter {
    private int threadRunCounter;

    public int getThreadRunCounter() {
        return threadRunCounter;
    }

    public void setThreadRunCounter(int threadRunCounter) {
        System.out.println("Запущено процессов: " + threadRunCounter);
        int old = this.threadRunCounter;
        this.threadRunCounter = threadRunCounter;
        pcs.firePropertyChange("threadRunCounter", old, threadRunCounter);
    }

    private final PropertyChangeSupport pcs = new PropertyChangeSupport(this);

    public void addPropertyChangeListener(PropertyChangeListener listener) {
        this.pcs.addPropertyChangeListener(listener);
    }

    public void removePropertyChangeListener(PropertyChangeListener listener) {
        this.pcs.removePropertyChangeListener(listener);
    }

    public void threadClosed() {
        this.setThreadRunCounter(this.threadRunCounter - 1);
    }
}

class MyWorker extends SwingWorker<Void, Void> {
    private Counter counter;
    private String processName;

    public MyWorker(Counter counter, String processName) {
        this.counter = counter;
        this.processName = processName;
    }

    @Override
    protected Void doInBackground() throws Exception {
        Random r = new Random();
        int time = 1000 * r.nextInt(5);
        Thread.sleep(time);
        return null;
    }

    @Override
    protected void done() {
        System.out.println(this.processName + " - done");
        counter.threadClosed();
    }
}

class BackgrProcessAction extends AbstractAction {
    private Counter counter;
    private int threadCount;

    public BackgrProcessAction(int threadCount, Counter counter) {
        this.counter = counter;
        this.threadCount = threadCount;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        counter.setThreadRunCounter(threadCount);
        for (int idx = 0; idx < threadCount; idx++) {
            new MyWorker(counter, "Процесс №" + idx).execute();
        }
    }
}

public class RunnableClass extends JFrame {

    private static final int THREAD_COUNT = 10;

    private static void createAndShowGui() {
        RunnableClass runnableClass = new RunnableClass();
        JFrame frame = new JFrame("Test");
        frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

        Counter counter = new Counter();
        JButton jButton = new JButton(new BackgrProcessAction(THREAD_COUNT, counter));
        jButton.setText("Запуск");
        frame.add(jButton);

        counter.addPropertyChangeListener(evt -> {
            jButton.setEnabled(!((Integer) evt.getNewValue() > 0));
        });


        frame.pack();
        frame.setLocationByPlatform(true);
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                createAndShowGui();
            }
        });
    }
}