private static void NestIterator(ITask currentTask) { ITask t = currentTask; Handler arbiterCleanup = t.ArbiterCleanupHandler; t.ArbiterCleanupHandler = delegate { t.ArbiterCleanupHandler = arbiterCleanup; TaskExecutionWorker.ExecuteTask(ref t, t.TaskQueue, true); }; currentTask.TaskQueue.Enqueue(t); }
private void AddWorker(ThreadPriority priority, ApartmentState apartmentState, int maxThreadStackSize) { TaskExecutionWorker taskExecutionWorker = new TaskExecutionWorker(this); Thread thread = new Thread(new ThreadStart(taskExecutionWorker.ExecutionLoop), maxThreadStackSize); thread.SetApartmentState(apartmentState); thread.Name = _name; thread.Priority = priority; thread.IsBackground = (DispatcherOptions.None < (_options & DispatcherOptions.UseBackgroundThreads)); taskExecutionWorker._thread = thread; _taskExecutionWorkers.Add(taskExecutionWorker); _cachedWorkerListCount++; }
internal void Signal() { if (_cachedWorkerListCount == 0) { Dispatcher.LogError("Dispatcher disposed, will not schedule task", new ObjectDisposedException("Dispatcher")); return; } Interlocked.Increment(ref _pendingTaskCount); for (int i = 0; i < _cachedWorkerListCount; i++) { TaskExecutionWorker taskExecutionWorker = _taskExecutionWorkers[i]; if (taskExecutionWorker.Signal()) { return; } } }
public static void ExecuteInCurrentThreadContext(object t) { ITask task = (ITask)t; try { TaskExecutionWorker.ExecuteTask(ref task, task.TaskQueue, false); Dispatcher.SetCurrentThreadCausalities(null); } catch (Exception ex) { if (TaskExecutionWorker.IsCriticalException(ex)) { throw; } TaskExecutionWorker.HandleException(task, ex); } }
private static void ExecuteTask(ref ITask currentTask, DispatcherQueue p, bool bypassExecute) { Handler arbiterCleanupHandler = currentTask.ArbiterCleanupHandler; IteratorContext iteratorContext; if (bypassExecute) { iteratorContext = null; } else { iteratorContext = TaskExecutionWorker.ExecuteTaskHelper(currentTask); } if (iteratorContext == null) { iteratorContext = (IteratorContext)currentTask.LinkedIterator; } if (iteratorContext != null) { Dispatcher.SetCurrentThreadCausalities(iteratorContext._causalities); TaskExecutionWorker.MoveIterator(ref currentTask, iteratorContext, ref arbiterCleanupHandler); if (currentTask != null) { currentTask.LinkedIterator = iteratorContext; currentTask.TaskQueue = p; iteratorContext = TaskExecutionWorker.ExecuteTaskHelper(currentTask); if (iteratorContext != null) { TaskExecutionWorker.NestIterator(currentTask); } } } if (arbiterCleanupHandler != null) { if (currentTask != null) { currentTask.ArbiterCleanupHandler = null; } arbiterCleanupHandler(); } }
internal void ExecutionLoop() { CheckStartupComplete(); while (true) { IL_06: int num = 0; int num2 = 0; ITask currentTask = null; try { bool flag = false; while (true) { if (num == 0) { if (_thread == null) { break; } WaitForTask(flag); } num2++; num = 0; int cachedDispatcherQueueCount = _dispatcher._cachedDispatcherQueueCount; for (int i = 0; i < cachedDispatcherQueueCount; i++) { if (cachedDispatcherQueueCount != _dispatcher._cachedDispatcherQueueCount) { goto Block_5; } DispatcherQueue dispatcherQueue; try { dispatcherQueue = _dispatcher._dispatcherQueues[(i + num2) % cachedDispatcherQueueCount]; } catch { goto IL_06; } if (_isFastTimerLogicEnabled) { flag |= dispatcherQueue.CheckTimerExpirations(); } if (dispatcherQueue.TryDequeue(out currentTask)) { num += dispatcherQueue.Count; TaskExecutionWorker.ExecuteTask(ref currentTask, dispatcherQueue, false); } } } Dispatcher.ClearCausalities(); CheckShutdownComplete(); Dispatcher.ClearCausalities(); break; Block_5: continue; } catch (Exception ex) { if (TaskExecutionWorker.IsCriticalException(ex)) { throw; } TaskExecutionWorker.HandleException(currentTask, ex); continue; } } }
public static void ExecuteNow(DispatcherQueue dispatcherQueue, ITask task) { task.TaskQueue = dispatcherQueue; TaskExecutionWorker.ExecuteInCurrentThreadContext(task); }