filetage apparaît pour exécuter les threads de manière séquentielle

Je suis en train d'utiliser des threads en Python projet sur lequel je travail, mais les threads ne semblent pas se comporter comme ils sont censés dans mon code. Il semble que tous les threads s'exécutent de façon séquentielle (c'est à dire thread2 commence après 1 thread se termine, ils ne commencent à la même heure). J'ai écrit un script simple pour tester cela, et qui gère les threads de manière séquentielle.

import threading

def something():
    for i in xrange(10):
        print "Hello"

def my_thing():
    for i in xrange(10):
        print "world"   

threading.Thread(target=something).start()
threading.Thread(target=my_thing).start()

Ici la sortie-je obtenir de l'exécutant:

Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello
world
world
world
world
world
world
world
world
world
world

Le même comportement est observé avec le plus grand nombre d'itérations de la boucle.

J'ai essayé de chercher sur le web et plus SI des réponses, mais je ne pouvais pas trouver quelque chose qui a aidé.
Quelqu'un peut s'il vous plaît signaler quel est le problème avec ce code?

InformationsquelleAutor MAK | 2009-11-08
  1. 14

    Actuellement en python, les threads se changer après l'exécution d'un certain montant de bytecode instructions. Ils ne fonctionnent pas en même temps. Vous n'aurez que des threads s'exécutant en parallèle lorsque l'un d'eux appelle quelques-I/O-intensif ou pas python-affectant le module qui permet de libérer GIL (global interprète de verrouillage).

    Je suis sûr que vous obtiendrez la sortie mélangés si vous vous cognez le nombre de boucles à quelque chose comme 10000. Rappelez-vous que simplement la ponte du deuxième thread prend également "beaucoup" de temps.

    • Même comportement avec 10000 itérations
    • Sur le projet sur lequel je travaille, l'un des fils est une boucle infinie qui écoute les messages et les appels à une fonction de rappel à mesure qu'ils arrivent. Il vient de blocs de tous les autres threads. Malheureusement, le code de boucle ne peut pas être modifié (je viens d'appeler la méthode run() d'une classe à l'intérieur de la discussion).
    • Lorsque je lance le script comme ceci: ./pythr.py | uniq -c j'obtiens: 8969 Bonjour | 1 Bonjour tout le monde | 6626 monde | 1 | 3373 monde | 1030 Bonjour. De sorte qu'il n'changement de contrôle - pas si souvent...
    • Un autre moyen de résoudre ce problème est d'utiliser multiprocessing instread de threading module. Afin que votre code s'exécute en parallèle.
    • J'ai eu de l'exécution parallèle sur l'utilisation de 100 000 itérations.
    • Merci. Multitraitement résolu le problème dans mon projet de code.

    InformationsquelleAutor viraptor
  2. 11

    Dans le temps, il prend la deuxième thread pour lancer le premier fil des boucles et des tirages déjà.

    Ici, ça ressemble à ça, vous pouvez voir le 2ème fil de départ après le premier émis quelques bonjours.

    Hello
Hello
Hello
Hello
Hello
Helloworld

Helloworld

Helloworld

Helloworld

Helloworld

world
world
world
world
world

    Btw: Votre exemple n'est pas pertinent du tout. La seule raison de Threads est IO, IO est lente. Lorsque vous ajoutez un peu de sommeil pour simuler IO il devrait fonctionner comme prévu:

    import threading
from time import sleep

def something():
    for i in xrange(10):
        sleep(0.01)
        print "Hello"

def my_thing():
    for i in xrange(10):
        sleep(0.01)
        print "world"

threading.Thread(target=something).start()
threading.Thread(target=my_thing).start()

    un mélange sauvage apparaît:

    worldHello

Helloworld

Helloworld

worldHello

Helloworld

Helloworld

worldHello

Helloworld

worldHello

Helloworld
    • Je ne suis pas sortie comme ça, même avec beaucoup plus grand/plus petit nombre d'itérations de la boucle. Sur mon ordinateur, il est toujours séquentielle. Je pense que c'est système d'exploitation/processeur dépend, comme abyx suggéré.
    • Comme je l'ai dit dans ma question, c'est juste un exemple pour mon problème, pas le code, je travaille avec (ce qui est beaucoup plus grande). Dans mon code, l'un des fils exécute une boucle à l'écoute pour dbus signaux.
    InformationsquelleAutor Jochen Ritzel
  3. 4

    Le comportement peut aussi changer en fonction de si le système dispose d'un processeur unique ou de plusieurs processeurs, comme l'a expliqué ce discours par David Beazley.

    Comme viraptor dit, le premier thread libère le GIL après l'exécution de sys.getcheckinterval() bytecode (100 par défaut). Pour crudly résumer ce que David Beazley dit, sur un système à processeur unique de la deuxième thread va alors avoir une chance de prendre le dessus. Cependant sur un système multi-core le deuxième thread peut être en cours d'exécution sur une autre base, et le premier thread va essayer d'acquérir le verrou et réussirez probablement depuis l'OS n'aura pas eu le temps de passer des processeurs. Cela signifie que dans un système multi-core avec un CPU fil les autres threads ne peut jamais obtenir un coup d'oeil dans.

    Le chemin de ronde, c'est pour ajouter une instruction de mise en veille à la fois de la boucle de sorte qu'ils ne sont plus liées à l'UC.

    InformationsquelleAutor Dave Kirby
  4. 3

    Cela dépend vraiment de votre Système d'Exploitation planificateur, votre processeur.

    Autre que cela, il est connu que Disponible les threads ne sont pas parfait à cause de la GIL(PDF), qui, en bref, cela signifie que beaucoup de temps threads ne sont exécutées de manière séquentielle, ou quelque chose du genre.

    • Tu veux sans doute dire que Disponible threads souffrent de la GIL... Il n'y a pas de GIL, disons, Jython.
    • vous avez raison, j'ai mis à jour la réponse
    InformationsquelleAutor abyx