Aus thread auf Formular zugreifen

l'abra d'or

Nimm in ThreadMinus() das "threadsRunning--" raus, dann kannst du dir vorstellen was passiert. Der Mutex locked vor dem ThreadPlus() und unlocked erst nach dem ThreadMinus. Das heißt, dass maximal ein Thread gerade in der run() arbeitet. Fängt er an, zählt er eins hoch, danach wieder eins runter, dann kommt der nächste Thread.

Versuche ohne dem globalen Murkszeugs (sry :P) auszukommen, dass die Threads auch wirklich parallel arbeiten können.

Ich habe jetzt alles in eine Klasse ausgelagert und das Objekt global deklariert.
Wie genau soll das jetzt mit dem Mutex funktionieren ?

void MyThread::run()
{
    QString proxy;

    ThreadPlus(); //->zugriff auf gem. variable

    gl.id++;//->zugriff auf gem. variable
    int threadId = gl.id;//->zugriff auf gem. variable

        while(gl.current < gl.proxyliste.count())//->zugriff auf gem. variable
        {

               threadId = gl.id;//->zugriff auf gem. variable

                proxy = gl.proxyliste[gl.current];//->zugriff auf gem. variable

                emit checking(proxy, threadId);
                emit checked(true, proxy);

        }

    ThreadMinus();//->zugriff auf gem. variable
}

So wie ich das sehe, muss fast überall mit dem Mutex-Objekt gelockt werden.

l'abra d'or

Jetzt hast du nur das Problem verlagert. Anstatt vielen globalen Variablen hast du jetzt eine. Löst dein Problem aber nicht.

Ich habe gemeint, dass du komplett ohne globalen Variablen arbeitest. Wenn du wirklich alle Threads parallel arbeiten lassen willst, und die run() am anfang den Mutex locked und am Ende erst wieder frei gibt, kann maximal ein Thread gleichzeitig laufen - wie schon einmal gesagt. Wenn du hingegen keine globale Mutex (weil keine globalen Variablen) hast, kann jeder Thread machen was er will, ohne auf die Synchronisation achten zu müssen.

Als erstes musst du dir dazu natürlich überlegen, welche Informationen du wie und wohin verlagern kannst.
Das Threads zählen kannst du zum Beispiel gleich ins MainWindow (welcher ja deine Threads startet) schieben. Vor dem Starten in MaineWindow Variable hochzählen, Connecte jedes finished()-Signal eines jeden Threads auf einen Slot, in dem du wieder dekrementierst.
Das current-Thread sollte sowieso als Variable in den jeweiligen Thread (wenn das denn überhaupt von Belang ist). Dazu musst du einen passenden Konstruktor anbieten - und damit fällt dein statisches Thread-Array flach (zu unflexibel und kompliziert). Programmiere C++ und verwende einen dynamischen Container, z.B. QVector<MyThread*>.

Und - tata - du brauchst keine einzige globale Variable mehr, Mutex locken kannst du dir auch schenken.