Partage de la transaction de partage entre threads

Question

J'ai une classe qui exécute du code transactionnel.
laisse supposer:

class Worker 
{ 
    public void doWork() 
    { 
     //I do not want to create a new transaction. Instead, i want to use the environmenttransaction used by the caller of this method 
     using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required))    { 
      workItem1(); 
      workItem2(); 
      workItem3(); 
      scope.Complete(); 
     } 
    } 

Maintenant, j'ai quelques fils qui exécutent ce code:

Worker worker = new Worker(); 
using (TransactionScope transaction = new TransactionScope()) 
{ 
    Thread Thread1 = new Thread(new ThreadStart(worker.doWork)); 
    Thread1.Start(); 
    Thread Thread2 = new Thread(new ThreadStart(worker.doWork)); 
    Thread2.Start(); 
    Thread Thread3 = new Thread(new ThreadStart(worker.doWork)); 
    Thread3.Start(); 

    Thread.Sleep(10000); //this should be enough to all the workers finish their job 

    transaction.Complete(); 
} 

Chaque thread crée une propre transaction. Comment puis-je partager la même transaction entre tous les threads?

Answer 1

Le code que vous avez créera une condition de concurrence. Vous appelez presque immédiatement scope.complete avant la fin de vos discussions.

Cependant, même si chaque collaborateur crée une étendue de transaction, celle-ci est en fait imbriquée par .Net dans la portée de transaction de niveau supérieur, si une nouvelle est créée.

Si vous souhaitez avoir une transaction multicouche imbriquée, vous pouvez créer la nouvelle étendue avec ScopeOption.RequiresNew. Mais ceci est la réponse à une vraie question, c'est pourquoi vous voudriez faire ceci. Les transactions signifient intrinsèquement que votre travail est en quelque sorte séquentiel ou critique pour se produire dans un certain ordre. Si vous pouvez effectuer le parallélisme du travail, essayez de le faire dans des transactions séparées, dans la mesure du possible, limitez la portée au temps le plus court possible pour empêcher les verrouillages, etc.

Answer 2

Le problème avec votre code est que vous n'êtes pas attendant tous les fils pour terminer leur travail avant d'appeler:

  transaction.Complete(); 

donc, l'un de vos fils peut appeler cette méthode avant votre transaction multithread complète comme un atomique. Vous devrez probablement utiliser la classe Semaphore pour éviter la collision.

Aussi, je voudrais examiner en utilisant PLinq si votre environnement le permet.

Answer 3

Vous pouvez jeter un oeil à la classe DependentTransaction qui est utile pour la transaction entre plusieurs threads. Voir le documentation pour cela.