ConcurrentExclusiveSchedulerPair.cs System::Threading::Tasks::ConcurrentExclusiveSchedulerPair System::Threading::Tasks::ConcurrentExclusiveSchedulerPair::SchedulerDebuggerView System::Threading::Tasks::ConcurrentExclusiveSchedulerPair::InnerTaskScheduler System System::Threading System::Threading::Tasks // //ConcurrentExclusiveSchedulerPair.cs // //Authors: //Jérémie"Garuma"Laval<jeremie.laval@gmail.com> //MarekSafar<marek.safar@gmail.com> // //Copyright(c)2011Jérémie"Garuma"Laval //Copyright2012Xamarin,Inc(http://www.xamarin.com) // //Permissionisherebygranted,freeofcharge,toanypersonobtainingacopy //ofthissoftwareandassociateddocumentationfiles(the"Software"),todeal //intheSoftwarewithoutrestriction,includingwithoutlimitationtherights //touse,copy,modify,merge,publish,distribute,sublicense,and/orsell //copiesoftheSoftware,andtopermitpersonstowhomtheSoftwareis //furnishedtodoso,subjecttothefollowingconditions: // //Theabovecopyrightnoticeandthispermissionnoticeshallbeincludedin //allcopiesorsubstantialportionsoftheSoftware. // //THESOFTWAREISPROVIDED"ASIS",WITHOUTWARRANTYOFANYKIND,EXPRESSOR //IMPLIED,INCLUDINGBUTNOTLIMITEDTOTHEWARRANTIESOFMERCHANTABILITY, //FITNESSFORAPARTICULARPURPOSEANDNONINFRINGEMENT.INNOEVENTSHALLTHE //AUTHORSORCOPYRIGHTHOLDERSBELIABLEFORANYCLAIM,DAMAGESOROTHER //LIABILITY,WHETHERINANACTIONOFCONTRACT,TORTOROTHERWISE,ARISINGFROM, //OUTOFORINCONNECTIONWITHTHESOFTWAREORTHEUSEOROTHERDEALINGSIN //THESOFTWARE. // // #ifNET_4_5||UNITY_5_3_OR_NEWER usingSystem; usingSystem.Threading; usingSystem.Collections.Generic; usingSystem.Collections.Concurrent; usingSystem.Diagnostics; namespaceSystem.Threading.Tasks { [DebuggerDisplay("Concurrent={ConcurrentTaskCount},Exclusive={ExclusiveTaskCount}")] [DebuggerTypeProxy(typeof(SchedulerDebuggerView))] publicclassConcurrentExclusiveSchedulerPair { sealedclassSchedulerDebuggerView { readonlyConcurrentExclusiveSchedulerPairowner; publicSchedulerDebuggerView(ConcurrentExclusiveSchedulerPairowner) { this.owner=owner; } publicIEnumerable<Task>ScheduledConcurrent{ get{ returnowner.concurrentTasks; } } publicIEnumerable<Task>ScheduledExclusive{ get{ returnowner.exclusiveTasks; } } publicTaskSchedulerTargetScheduler{ get{ returnowner.target; } } } readonlyintmaxConcurrencyLevel; readonlyintmaxItemsPerTask; readonlyTaskSchedulertarget; readonlyTaskFactoryfactory; readonlyActiontaskHandler; readonlyConcurrentQueue<Task>concurrentTasks=newConcurrentQueue<Task>(); readonlyConcurrentQueue<Task>exclusiveTasks=newConcurrentQueue<Task>(); //readonlyReaderWriterLockSlimrwl=newReaderWriterLockSlim(); readonlyTaskCompletionSource<object>completion=newTaskCompletionSource<object>(); readonlyInnerTaskSchedulerconcurrent; readonlyInnerTaskSchedulerexclusive; intnumTask; classInnerTaskScheduler:TaskScheduler { readonlyConcurrentExclusiveSchedulerPairscheduler; readonlyConcurrentQueue<Task>queue; publicInnerTaskScheduler(ConcurrentExclusiveSchedulerPairscheduler, ConcurrentQueue<Task>queue) { this.scheduler=scheduler; this.queue=queue; } publicintTaskCount{ get{ returnqueue.Count; } } publicoverrideintMaximumConcurrencyLevel{ get{ returnscheduler.maxConcurrencyLevel; } } protectedinternaloverridevoidQueueTask(Taskt) { scheduler.DoQueue(t,queue); } protectedoverrideboolTryExecuteTaskInline(Tasktask,booltaskWasPreviouslyQueued) { if(task.Status!=TaskStatus.Created) returnfalse; task.RunSynchronously(scheduler.target); returntrue; } publicvoidExecute(Taskt) { TryExecuteTask(t); } [MonoTODO("Onlyusefulfordebuggersupport")] protectedoverrideIEnumerable<Task>GetScheduledTasks() { thrownewNotImplementedException(); } } publicConcurrentExclusiveSchedulerPair():this(TaskScheduler.Current) { } publicConcurrentExclusiveSchedulerPair(TaskSchedulertaskScheduler):this(taskScheduler,taskScheduler.MaximumConcurrencyLevel) { } publicConcurrentExclusiveSchedulerPair(TaskSchedulertaskScheduler,intmaxConcurrencyLevel) :this(taskScheduler,maxConcurrencyLevel,-1) { } publicConcurrentExclusiveSchedulerPair(TaskSchedulertaskScheduler,intmaxConcurrencyLevel,intmaxItemsPerTask) { this.target=taskScheduler; this.maxConcurrencyLevel=maxConcurrencyLevel; this.maxItemsPerTask=maxItemsPerTask; this.factory=newTaskFactory(taskScheduler); this.taskHandler=InternalTaskProcesser; this.concurrent=newInnerTaskScheduler(this,concurrentTasks); this.exclusive=newInnerTaskScheduler(this,exclusiveTasks); } publicvoidComplete() { completion.SetResult(null); } publicTaskSchedulerConcurrentScheduler{ get{ returnconcurrent; } } privateintConcurrentTaskCount{ get{ returnconcurrent.TaskCount; } } publicTaskSchedulerExclusiveScheduler{ get{ returnexclusive; } } privateintExclusiveTaskCount{ get{ returnexclusive.TaskCount; } } publicTaskCompletion{ get{ returncompletion.Task; } } voidDoQueue(Tasktask,ConcurrentQueue<Task>queue) { queue.Enqueue(task); SpinUpTasks(); } voidInternalTaskProcesser() { inttimes=0; //constintlockWaitTime=2; while(!concurrentTasks.IsEmpty||!exclusiveTasks.IsEmpty){ if(maxItemsPerTask!=-1&&++times==maxItemsPerTask) break; thrownewNotImplementedException(); /* boollocked=false; try{ if(!concurrentTasks.IsEmpty&&rwl.TryEnterReadLock(lockWaitTime)){ locked=true; Tasktask; while(concurrentTasks.TryDequeue(outtask)){ RunTask(task); } } }finally{ if(locked){ rwl.ExitReadLock(); locked=false; } } try{ if(!exclusiveTasks.IsEmpty&&rwl.TryEnterWriteLock(lockWaitTime)){ locked=true; Tasktask; while(exclusiveTasks.TryDequeue(outtask)){ RunTask(task); } } }finally{ if(locked){ rwl.ExitWriteLock(); } } */ } //TODO:there'saracehere,taskadding+spinupcheckmaybedonewhilehere Interlocked.Decrement(refnumTask); } voidSpinUpTasks() { intcurrentTaskNumber; do{ currentTaskNumber=numTask; if(currentTaskNumber>=maxConcurrencyLevel) return; }while(Interlocked.CompareExchange(refnumTask,currentTaskNumber+1,currentTaskNumber)!=currentTaskNumber); factory.StartNew(taskHandler); } voidRunTask(Tasktask) { concurrent.Execute(task); } } } #endif