Équivalent C # pour Java ExecutorService.newSingleThreadExecutor (), ou: comment sérialiser l'accès mulithread à une ressource

J'ai un couple de situations dans mon code où plusieurs threads peuvent créer des éléments de travail qui, pour diverses raisons, ne devrait pas être fait en parallèle. J'aimerais assurez-vous que le travail s'effectue dans une FIFO façon, indépendamment de ce thread, il vient de. En Java, je l'avais mis les éléments de travail sur un seul thread ExecutorService; est-il un équivalent en C#? J'ai pavées quelque chose ensemble avec un Queue et un tas de lock(){} blocs, mais il serait agréable d'être en mesure d'utiliser quelque chose de hors-the-shelf et testé.

Mise à jour: quelqu'un a une expérience avec le Système.Le filetage.Tâches? A-t-elle une solution pour ce genre de chose? Je suis en train d'écrire un Monotouch app alors qui sait si je pourrais trouver une version rétroportés de ce que j'ai pu obtenir pour travailler, mais il aurait au moins quelque chose à penser pour l'avenir.

Mise à jour #2 Pour les développeurs C#, peu familiers avec les bibliothèques Java je parle, fondamentalement, je veux quelque chose qui permet à plusieurs fils à la main en arrêt de travail les éléments tels que tous les travaux seront exécutés sur un seul thread (ce qui n'est pas l'un de l'appel de threads).

Mise à jour, 6/2018: Si j'étais l'architecture d'un système similaire, maintenant, je serais probablement utiliser Réactif Extensions comme par Matt Craig répondre. Je pars Zachary Yates réponse l'a accepté, bien que, parce que si vous êtes en train de penser en Rx-vous ne serait probablement pas même de poser cette question, et je pense que ConcurrentQueue est plus facile de bodge dans un pre-Rx programme.

source d'informationauteur David Moles

  1. 3

    Vous pouvez utiliser ConcurrentQueue(si monotouch prend en charge .net 4?) c'est thread-safe et je pense la mise en œuvre est en fait lockless. Cela fonctionne assez bien si vous avez un travail de longue haleine (comme dans un service windows).

    Généralement, votre problème sonne comme vous avez plusieurs producteurs avec un seul consommateur.

    var work = new ConcurrentQueue<Item>();
var producer1 = Task.Factory.StartNew(() => {
    work.Enqueue(item); //or whatever your threads are doing
});
var producer2 = Task.Factory.StartNew(() => {
    work.Enqueue(item); //etc
});
var consumer = Task.Factory.StartNew(() => {
    while(running) {
        Item item = null;
        work.TryDequeue(out item);
    }
});
Task.WaitAll(producer1, producer2, consumer);

    Vous devez utiliser BlockingCollection si vous avez fini de pool de postes de travail. Voici une page MSDN montrant toutes les nouvelles concurrentes des types de collection.

  2. 1

    Je croire cela peut être fait à l'aide d'un SynchronizationContext. Cependant, j'ai seulement fait pour publier sur le thread de l'INTERFACE utilisateur, qui dispose déjà d'un contexte de synchronisation (si l'on dit être installé) fournis par .NET -- je ne sais pas comment le préparer pour l'utilisation d'un "vanille thread" si.

    Quelques liens que j'ai trouvé pour "custom synchronizationcontext fournisseur" (je n'ai pas eu le temps de passer en revue ces, ne comprennent pas pleinement le travail/le contexte, ni aucune information supplémentaire):

    1. La recherche d'un exemple d'une coutume SynchronizationContext (Requis pour les tests unitaires)

    2. http://codeidol.com/csharp/wcf/Concurrency-Management/Custom-Service-Synchronization-Context/

    Heureux de codage.

  3. 1

    Il n'y a plus contemporains solution maintenant disponible - le EventLoopScheduler classe.

  4. 0

    Non indigènes, autant que je sache, mais regardez ceci:
    Série Exécuteur de Tâches, est-ce "thread-safe"?

  5. -2

    Comme je l'ai écrit dans les commentaires, vous avez découvert par vous-même que la lock déclaration peut faire le travail.

    Si vous êtes intéressé à obtenir un "conteneur" qui peut simplifier la tâche de gérer une file d'attente d'éléments de travail, regarder la ThreadPool classe.

    Je pense que, dans un système bien conçu de l'architecture, avec ces deux elemnts (ThreadPool classe et lock déclaration), vous pouvez facilement et avec succès sérialiser l'accès aux ressources.