.NET 4.5'te paralel görevler nasıl oluşturulur

Question

.NET yineleyici'yi paralel Görevler/Beklet ile kullanmak isterim ?. Bunun gibi bir şey: .NET, bunu yerel olarak ele alamamaktadır. @svick tarafından şimdiye kadar en iyi cevap - AsParallel() kullanın.

BONUS: Birden çok yayıncı ve tek bir aboneyi uygulayan basit bir uyumsuz/bekletme kodu var mı? Abone verilecek ve barlar işleyecek. (yalnızca çekirdek kitaplıkları)

Answer 1

Bu PLINQ için bir iş gibi görünüyor 'Kendi rulo' konusunda size ilham olacak:

return source.AsParallel().Select(s => ExecuteOrDownloadSomething(s)); 

Bu kısa sürede tamamlanır tamamlanmaz her sonucu dönen, iş parçacığı sınırlı sayıda kullanılarak paralel olarak temsilci çalıştırır. ExecuteOrDownloadSomething() yöntem IO bağlı ise

(örn aslında bir şey indirebilir) ve async kullanarak sonra, konuları atık istemiyorum - mantıklı olabilir await, ama daha karmaşık olacaktır.

async'dan tam olarak yararlanmak istiyorsanız, IEnumerable döndürmemelisiniz, çünkü bu eşzamanlıdır (yani, herhangi bir öğe yoksa bloklar). Ne gerek asenkron koleksiyon çeşit, ve kullanabileceğiniz ISourceBlock (özellikle TransformBlock) bunun için TPL veri akışı den: kaynağıdır

ISourceBlock<TDst> Foo<TSrc, TDest>(IEnumerable<TSrc> source) 
{ 
    var block = new TransformBlock<TSrc, TDest>(
     async s => await ExecuteOrDownloadSomethingAsync(s), 
     new ExecutionDataflowBlockOptions 
     { 
      MaxDegreeOfParallelism = DataflowBlockOptions.Unbounded 
     }); 

    foreach (var item in source) 
     block.Post(item); 

    block.Complete(); 

    return block; 
} 

ise “yavaş” (yani sonuçlarını işlemeye başlamak istiyorum Foo(), source yinelenen tamamlandı), foreach ve Complete() çağrıyı ayrı bir Task'a taşımak isteyebilirsiniz. Daha da iyi bir çözüm, source'u ISourceBlock<TSrc>'a da yapmak olabilir.

Answer 2

MS robotics ekibi tarafından yapılan eşzamansız kitaplıkta, eşzamanlı olmayan kod sağlamak için yineleyicinin kullanılmasına izin veren eşzamanlılık ilkelleri vardı.

Kütüphane (CCR) ücretsizdir (Ücretsiz olmak için kullanmadı). Güzel bir tanıtım makale burada bulunabilir: Concurrent affairs

Belki Net görev kütüphanede yanında bu kütüphaneyi kullanabilir, ya da

Answer 3

Yani gerçekten yapmak istediğinizi ne zaman tamamladıklarına bağlı olarak bir dizi görev sipariş etmektir. Bu korkunç karmaşık değil:

public static IEnumerable<Task<T>> Order<T>(this IEnumerable<Task<T>> tasks) 
{ 
    var input = tasks.ToList(); 

    var output = input.Select(task => new TaskCompletionSource<T>()); 
    var collection = new BlockingCollection<TaskCompletionSource<T>>(); 
    foreach (var tcs in output) 
     collection.Add(tcs); 

    foreach (var task in input) 
    { 
     task.ContinueWith(t => 
     { 
      var tcs = collection.Take(); 
      switch (task.Status) 
      { 
       case TaskStatus.Canceled: 
        tcs.TrySetCanceled(); 
        break; 
       case TaskStatus.Faulted: 
        tcs.TrySetException(task.Exception.InnerExceptions); 
        break; 
       case TaskStatus.RanToCompletion: 
        tcs.TrySetResult(task.Result); 
        break; 
      } 
     } 
     , CancellationToken.None 
     , TaskContinuationOptions.ExecuteSynchronously 
     , TaskScheduler.Default); 
    } 

    return output.Select(tcs => tcs.Task); 
} 

Yani burada biz o zaman görevlerin her geçmesi ve bir BlockingCollection sonraki tamamlama kaynağını alır ve bu hataların nedeni ayarlayan bir devamı ayarlamak, her giriş görev için bir TaskCompletionSource oluşturun. Tamamlanan ilk görev, geri gönderilen ilk tcs'i yakalar, ikinci görev tamamlandığında geri gönderilen ikinci tcs olur ve böyle devam eder.

Şimdi kod oldukça basit olur:

var tasks = collection.Select(item => LongRunningOperationThatReturnsTask(item)) 
    .Order(); 
foreach(var task in tasks) 
{ 
    var result = task.Result;//or you could `await` each result 
    //.... 
}