Sécurité des threads dans le dictionnaire Python

J'ai une classe qui contient un dictionnaire

class OrderBook:
    orders = {'Restaurant1': None,
              'Restaurant2': None,
              'Restaurant3': None,
              'Restaurant4': None}

    @staticmethod
    def addOrder(restaurant_name, orders):
        OrderBook.orders[restaurant_name] = orders

Et j'utilise 4 threads (un pour chaque restaurant) qui appellent la méthode OrderBook.addOrder. Voici la fonction exécutée par chaque thread:

def addOrders(restaurant_name):

    #creates orders
    ...

    OrderBook.addOrder(restaurant_name, orders)

Est-ce sûr ou dois-je utiliser un verrou avant d'appeler addOrder?

Les structures intégrées de Python sont thread-safe pour des opérations uniques, mais il peut parfois être difficile de voir où une instruction devient réellement plusieurs opérations.

Votre code doit être sûr. Gardez à l'esprit: un verrou ici n'ajoutera presque pas de frais généraux et vous donnera la tranquillité d'esprit.

http://effbot.org/pyfaq/what-kinds-of-global-value-mutation-are-thread-safe.htm a plus de détails.

Oui, les types intégrés sont intrinsèquement thread-safe: http://docs.python.org/glossary.html#term-global-interpreter-lock

Cela simplifie l'implémentation de CPython en rendant le modèle objet ( y compris les types intégrés critiques tels que dict ) implicitement sûr contre les accès simultanés.

Le guide de style de Google déconseille de s'appuyer sur l'atomicité de dict

Expliqué plus en détail sur: L'affectation de variable Python est-elle atomique?

Ne vous fiez pas à l'atomicité des types intégrés.

Alors que les types de données intégrés à Python tels que les dictionnaires semblent avoir des opérations atomiques, il existe des cas secondaires où ils ne sont pas atomiques (par exemple, si __hash__ou __eq__sont implémentés en tant que méthodes Python) et leur atomicité ne doit pas être invoquée. Vous ne devez pas non plus vous fier à l'affectation de variables atomiques (car cela dépend à son tour des dictionnaires).

Utilisez le Queuetype de données File d'attente du module comme moyen préféré de communiquer des données entre les threads. Sinon, utilisez le module de thread et ses primitives de verrouillage. Découvrez comment utiliser correctement les variables de condition afin de pouvoir les utiliser threading.Conditionau lieu d'utiliser des verrous de niveau inférieur.

Et je suis d'accord avec celui-ci: il y a déjà le GIL dans CPython, donc la performance de l'utilisation d'un verrou sera négligeable. Les heures passées à rechercher des bogues dans une base de code complexe seront beaucoup plus coûteuses lorsque ces détails d'implémentation CPython changent un jour.