programmation parallèle en .net 4.0

Question

J'ai lu sur la programmation parallèle et même maintenant encore un peu confus sur l'ensemble des concepts. Disons que j'ai un seul projet avec environ 5 classes qui interagissent et ont des variables locales dans les méthodes et les variables accessibles à toutes les méthodes dans une seule classe et même 1 ou 2 variables accessibles à toutes les classes accédées par instanciation. Maintenant, en utilisant les threads, je sais que les variables globales seraient remplacées par plusieurs threads s'il n'y avait pas de verrouillage appliqué, mais pas de variables locales à une méthode/fonction, non? Ainsi, si j'exécutais le projet plusieurs fois, ce qui signifiait un nouveau processus, les méthodes et les variables seraient sûres pour les threads et aucune corruption de données ne se produirait. Donc, pour implémenter la programmation parallèle en utilisant la fabrique de tâches, si je crée un projet qui crée des tâches et que chaque tâche exécute une instance d'un autre projet, les variables et les données ne devraient-elles pas être corrompues? Mais que se passe-t-il si j'avais les fichiers de sortie et qu'ils sont nommés par la sortie & datetime.now.tostring, y aurait-il des problèmes de conflit et je demande cela sachant que j'ai vu cela se produire en l'essayant.

dim factory as new taskfactory 
factory.startnew(addressof projectinstance.main) 

Maintenant, cela peut-être bon sens pour la plupart d'entre vous donc soyez doux sur la critique s'il vous plaît. merci d'apprécier toute réponse.

EDIT:

Ceci est le module de création de fichier dans l'une des classes:

Private Sub createXML() 
    num += 1 
    Dim fileList As New ArrayList 
    Dim counter As Integer = 0 
    Dim file As String = Module1.infile 
    xmlfile = directoryPath & "\Feed" & DateTime.Now.ToUniversalTime.ToString("yyyyMMddhhmmss") & endExtension 
    fileList.Add(xmlfile) 
    Thread.Sleep(2000) 
    Dim doc As XmlDocument = New XmlDocument 
    xwriter = New XmlTextWriter(xmlfile, Encoding.UTF8) 
    xwriter.Formatting = Formatting.Indented 
    xwriter.Indentation = 2 
    xwriter.WriteStartDocument(True) 
    xwriter.WriteStartElement("Posts") 
    Dim j As Integer = 0 
    For i As Integer = 0 To gXmlList.Count() - 1 
     j += 1 
     parseXML(gXmlList(i)) 

....

Answer 1

Ce sont les données multiples programme unique SPMD pattern. Vous créez essentiellement un graphe de programme ou d'objet séparé pour chaque tâche (une tâche est finalement programmée sur un thread). Les instances de variables qui sont globales dans le graphe d'objets seront correctes (donc pas de globals statiques) mais doivent toujours s'inquiéter des ressources partagées comme les fichiers. Une façon de résoudre ces types de problèmes est d'attribuer à chaque instance de tâche un identifiant unique, ou "rank", et de l'utiliser pour identifier les ressources et les nommer. Dans votre exemple de fichier, chaque tâche génère un fichier appelé myoutput_ {rank} .txt. Si ce que vous voulez réellement est un fichier, alors votre application doit implémenter une phase d'agrégation de post-traitement où elle fusionne les résultats. Cela se produit séquentiellement après que le parallélisme est terminé. Cela ressemble à une carte/réduire. Chacune de vos tâches parallèles exécute le même "programme" pour mapper certaines données d'entrée sur un ensemble de données de sortie (un fichier dans votre cas), puis dans une étape séparée, réduisez ou agrègez les résultats dans la réponse finale.

Voici un exemple:

static void Main() 
    { 
     const int maxJobs = 10; 

     // Run jobs and wait... 
     List<Task> tasks = new List<Task>(); 
     for (int rank = 0; rank < maxJobs; rank++) 
      tasks.Add(Task.Factory.StartNew((r) => { new MyApp().Main((int)r); }, rank)); 

     Task.WaitAll(tasks.ToArray()); 

     // Aggregate results... 
     StringBuilder sb = new StringBuilder(); 
     for (int rank = 0; rank < maxJobs; rank++) 
      sb.AppendLine(File.ReadAllText("results_" + rank + ".txt")); 

     Console.WriteLine(sb.ToString()); 
     File.WriteAllText("results_final.txt", sb.ToString()); 
     Console.ReadLine(); 
    } 

    public class MyApp 
    { 
     public void Main(int rank) 
     { 
      Console.WriteLine("Starting {0}", rank); 
      File.WriteAllText("results_" + rank + ".txt", "result data " + rank); 
     } 
    } 

La MyApp classe peut avoir autant état qu'il aime. Il peut même partager cet état avec des objets enfants, mais il ne doit pas avoir d'état statique ni d'état de partage avec des variables globales définies en lecture/écriture en dehors de MyApp.

Il est correct d'avoir un état global en lecture seule. Par exemple, toutes les instances de MyApp peuvent lire les données d'entrée d'un seul fichier. Ce qui n'est pas correct est d'avoir plusieurs instances de MyApp lisant et en écrivant dans une (seule) variable globale, instance d'objet ou autre ressource comme un fichier sans implémenter une forme de coordination (comme un verrou).

Dans l'exemple ci-dessus, chaque tâche crée un fichier results_ {rank} .txt local. Le contenu de ceux-ci est combiné dans un seul fichier de résultats, results_final.txt, dans une étape d'agrégation distincte.Il n'est pas possible de le faire en parallèle car toutes les tâches seraient alors écrites dans une seule ressource globale.

Beaucoup de ces concepts sont couverts dans le livre et les échantillons que vous pouvez trouver ici. Le contenu est également disponible (gratuitement) sur MSDN.

http://parallelpatterns.codeplex.com/