Progress track thread pool rather than each process

import random
import sys
import time
import uuid

from PyQt5.QtCore import QObject, QRunnable, QThreadPool, QTimer, pyqtSignal, pyqtSlot
from PyQt5.QtWidgets import (
    QApplication,
    QLabel,
    QMainWindow,
    QProgressBar,
    QPushButton,
    QVBoxLayout,
    QWidget,
)


class WorkerSignals(QObject):
    """
    Defines the signals available from a running worker thread.

    progress
        int progress complete,from 0-100
    """

    duration = pyqtSignal(str, int)
    finished = pyqtSignal(str)


class Worker(QRunnable):
    """
    Worker thread

    Inherits from QRunnable to handle worker thread setup, signals
    and wrap-up.
    """

    def __init__(self):
        super().__init__()
        self.job_id = uuid.uuid4().hex  # <1>
        self.signals = WorkerSignals()

    @pyqtSlot()
    def run(self):
        start_time = time.time()
        total_n = 1000
        delay = random.random() / 100  # Random delay value.
        for n in range(total_n):
            time.sleep(delay)

        end_time = time.time()
        self.signals.duration.emit(self.job_id, end_time-start_time)
        self.signals.finished.emit(self.job_id)


class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()

        layout = QVBoxLayout()

        self.duration = QLabel()

        button = QPushButton("START IT UP")
        button.pressed.connect(self.execute)

        layout.addWidget(self.duration)
        layout.addWidget(button)

        w = QWidget()
        w.setLayout(layout)

        # Dictionary holds the duration of current workers.
        self.worker_duration = {}

        self.setCentralWidget(w)

        self.show()

        self.threadpool = QThreadPool()
        print(
            "Multithreading with maximum %d threads" % self.threadpool.maxThreadCount()
        )

        self.timer = QTimer()
        self.timer.setInterval(100)
        self.timer.timeout.connect(self.refresh_duration)
        self.timer.start()

    def execute(self):
        self.cleanup() # Clear existing durations.

        for n in range(0, 4): # 4 per batch
            worker = Worker()
            worker.signals.duration.connect(self.update_duration)

            # Execute
            self.threadpool.start(worker)

    def cleanup(self):
        # Remove all previous durations.
        self.worker_duration = {}
        self.refresh_duration()

    def update_duration(self, job_id, duration):
        self.worker_duration[job_id] = duration

    def calculate_duration(self):
        if not self.worker_duration:
            return 0

        return sum(ms for ms in self.worker_duration.values())

    def refresh_duration(self):
        # Calculate total duration.
        duration = self.calculate_duration()
        self.duration.setText("{} ms ({} complete)".format(duration, len(self.worker_duration)))

app = QApplication(sys.argv)
window = MainWindow()
app.exec_()