À l'aide d'un dictionnaire mondial avec des threads en Python

Est d'y accéder/modifier le dictionnaire des valeurs thread-safe?

J'ai un mondial dictionnaire foo et plusieurs threads avec des id id1, id2, ... , idn. Est-il OK pour accéder et modifier foo's valeurs sans allouer un cadenas pour elle si l'on sait que chaque thread ne fonctionne qu'avec l'id de la valeur liée au, dire thread avec id1 ne fonctionne qu'avec foo[id1]?

  • Vous de à l'aide Disponible, droit?
  • oui, je suis de l'aide Disponible.
InformationsquelleAutor Alex | 2009-08-21
  1. 45

    En supposant Disponible: Oui et non. Il est réellement sans danger pour récupérer/sauvegarder les valeurs à partir d'un partage de dictionnaire dans le sens que simultanément plusieurs demandes de lecture/écriture de ne pas corrompre le dictionnaire. Cela est dû au mondial de l'interprète de verrouillage ("GIL") qui est géré par la mise en œuvre. Qui est:

    Un Thread en cours d'exécution:

    a = global_dict["foo"]

    Thread B en cours d'exécution:

    global_dict["bar"] = "hello"

    Thread C en cours d'exécution:

    global_dict["baz"] = "world"

    de ne pas corrompre le dictionnaire, même si tous les trois tentatives d'accès se produisent à la "même" temps. L'interprète va sérialiser dans certains undefined façon.

    Cependant, les résultats de la séquence suivante n'est pas défini:

    Thread:

    if "foo" not in global_dict:
   global_dict["foo"] = 1

    Thread B: 

    global_dict["foo"] = 2

    comme l'essai, l'ensemble dans Un thread n'est pas atomique ("time-of-contrôle/temps d'utilisation de la" race condition). Donc, il est généralement préférable, si vous verrouillez les choses:

    from threading import RLock

lock = RLock()

def thread_A():
    lock.acquire()
    try:
        if "foo" not in global_dict:
            global_dict["foo"] = 1
    finally:
        lock.release()

def thread_B():
    lock.acquire()
    try:
        global_dict["foo"] = 2
    finally:
        lock.release()
    • Serait global_dict.setdefault("foo", 1) dans Thread A faire de la nécessité d'un blocage inutile?
    • Suis-je la compréhension de ce correctement. Tant que im ajouter au dictionnaire sans modification, c'est sûr. ie dict['a'] = 1 dans un thread et dict['b'] = 2 dans le thread b est bien parce que les touches a et b ne sont pas les mêmes?
    • Pas de. Ce qui est sûr et ce qui ne dépend de votre application. Pensez à une classe, qui a les champs a et b et l'invariant, c'est exactement l'un de ces champs n'est pas None et l'autre est None. Sauf si l'accès est correctement contrefil, toute combinaison aléatoire de a is [not] None et b is [not] None peuvent être observables en violation flagrante de l'invariant, si seulement un "naïf" getter/setter est utilisé (pensez: def set_a(self,a): self.a = a; self.b = None if a is not None else self.b -- un des threads peut observer illégale membres au cours de l'exécution)
    • est-il un moyen pour moi de mettre le verrou sur le dictionnaire de discbased de l'écriture/mise à jour/supprimer?
    • initialisera automatiquement dans Disponible si la clé est entièrement composé d'objets internes mis en œuvre dans C. Le GIL vous protège de courses, tant que la mutation du cadre d'une opération se déroule sans octets de codes entre le début de la mutation et de le terminer, et dans le cas de la clé de l'insertion, vous obtenez ce comportement lorsque l' __eq__ et __hash__ d'un objet sont mis en œuvre en C, pas en Python code de niveau.
    • J'ai juste posé une question que quelqu'un modded comme étant un doublon de celui-ci. Ce qui est encore pas tout à fait clair pour moi, c'est si je peux compter sur if val == a_dict.setdefault( key, val ) à atomiquement d'insertion ET de savoir si la valeur a été inséré ou existait déjà.
    • En supposant que val était unique avant la tentative d'insertion (aucun autre thread ne peut essayer d'insérer une référence à la même val), vous pouvez utiliser if val is a_dict.setdefault(key, val): pour effectuer l'identité de l'objet de test à identifier correctement si une mise à jour a eu lieu. Il y a quelques exceptions à la règle (si val est interné str, par exemple str littérale, petit int, bool ou le vide tuple (), c'est un singleton; ils allaient passer à l'identité de l'objet de test, même si de manière indépendante "créé" dans des lieux différents).
    • Cela dit, pour la plupart des valeurs scalaires, il n'est pas très utile; le gros de cas d'utilisation pour l'atomicité avec setdefault est mutable structures. a_dict.set_default(key, []).append(val) est conforme en supposant que les touches ne sont jamais supprimés ou affecter de nouvelles valeurs, seulement setdefault-ed (ou de lire) avec la valeur résultante d'être muté en place.
    • Est-ce le cas pour Pypy? Selon la documentation, Pypy a également GIL, je suppose qu'il se comporte de la même manière: wiki.python.org/moin/GlobalInterpreterLock

    InformationsquelleAutor Dirk
  2. 23

    La meilleure, la plus sûre, portable moyen d'avoir chaque thread de travail avec des données indépendantes est:

    import threading
tloc = threading.local()

    Maintenant, chaque thread fonctionne avec une totalement indépendante tloc objet même si c'est un nom global. Le fil peut obtenir et définir les attributs sur tloc, utilisez tloc.__dict__ si elle spécifiquement besoin d'un dictionnaire, etc.

    Thread-local de stockage pour un thread s'en va à la fin du thread; des fils d'enregistrer leurs résultats définitifs, ont eux put leurs résultats, avant de résilier, dans une instance commune de Queue.Queue (qui est intrinsèquement thread-safe). De même, les valeurs initiales pour les données d'un thread est de travailler sur pourrait être le passage d'arguments lorsque le thread est démarré, ou d'être pris à partir d'un Queue.

    D'autres à moitié cuit, approches, comme en espérant que les opérations qui ressemblent atomique sont en effet atomique, peut arriver à travailler pour des cas spécifiques dans une version et mise à jour de Python, mais pourrait facilement être détruit par des mises à niveau ou les ports. Il n'y a pas de véritable raison du risque de tels problèmes lors de l'un de propre, propre, salubre et l'architecture y est très facile à organiser, portable, pratique, et rapide.

    InformationsquelleAutor Alex Martelli
  3. 14

    Depuis que j'ai besoin de quelque chose de similaire, j'ai atterri ici. Je résume vos réponses dans ce court extrait :

    #!/usr/bin/env python3

import threading

class ThreadSafeDict(dict) :
    def __init__(self, * p_arg, ** n_arg) :
        dict.__init__(self, * p_arg, ** n_arg)
        self._lock = threading.Lock()

    def __enter__(self) :
        self._lock.acquire()
        return self

    def __exit__(self, type, value, traceback) :
        self._lock.release()

if __name__ == '__main__' :

    u = ThreadSafeDict()
    with u as m :
        m[1] = 'foo'
    print(u)

    en tant que tel, vous pouvez utiliser le with construire pour tenir la serrure alors qu'il fait tripoter dans votre dict()

    InformationsquelleAutor yota
  4. 4

    La GIL prend soin de cela, si vous arrive d'être en utilisant CPython.

    mondiale interprète de verrouillage

    Le verrou en Python fils pour s'assurer que seul un thread s'exécute dans le Disponible de la machine virtuelle à la fois. Cela simplifie le Disponible de la mise en œuvre en veillant à ce que les deux processus peuvent accéder à la même mémoire en même temps. Le verrouillage de l'ensemble de l'interprète, il est plus facile pour l'interprète d'être multi-thread, au détriment d'une grande partie du parallélisme offert par des machines multi-processeur. Des Efforts ont été faits dans le passé pour créer un “libre-threaded” interprète (qui bloque de données partagée à un beaucoup plus fin de granularité), mais jusqu'à présent, aucun n'a réussi, en raison de la performance a souffert dans l'unique commune-processeur cas.

    Voir sont-serrures-inutile-dans-multi-threaded-python-code-parce-que-de-la-gil.

    • Qui concerne uniquement Disponible si.
    • À moins qu'il arrive à être à l'aide de Jython ou IronPython.
    • Léonard: me Battre pour elle 🙂
    • Cela ne signifie pas que vous pouvez compter sur la GIL. La clé peut être une instance d'une classe avec un __hash__ méthode, de sorte que plus de 1 Python bytecode instruction est exécutée et le fil peut basculer de toute façon. Ensuite, il y a des opérations d'e/S code natif et les sections de la libération de la GIL. Les verrous sont encore très bien d'une exigence de thread-safe code.
    InformationsquelleAutor gimel
  5. 1

    Comment ça marche?:

    >>> import dis
>>> demo = {}
>>> def set_dict():
...     demo['name'] = 'Jatin Kumar'
...
>>> dis.dis(set_dict)
  2           0 LOAD_CONST               1 ('Jatin Kumar')
              3 LOAD_GLOBAL              0 (demo)
              6 LOAD_CONST               2 ('name')
              9 STORE_SUBSCR
             10 LOAD_CONST               0 (None)
             13 RETURN_VALUE

    Chacune des instructions ci-dessus est exécuté avec GIL de verrouillage et STORE_SUBSCR instruction ajoute ou met à jour la clé+valeur de la paire dans un dictionnaire. Donc, vous voyez le dictionnaire de mise à jour est atomique et donc thread-safe.

    InformationsquelleAutor Jatin Kumar