public async void StartBackgroundJobs() { AddBackgroundInformation("Background jobs", "Starting background jobs"); if (BackgroundJobs == null) { try { InitializeBackgroundJobs(); } catch (Exception e) { AddBackgroundError("Starting error", e); } } //AddBackgroundInformation("Background jobs", "Starting background jobs 2"); foreach (var backgroundJob in BackgroundJobs) { //var thread = new Thread(new ParameterizedThreadStart(RunBackgroundEventLoop)); var task = Task.Run(async() => RunBackgroundEventLoop(backgroundJob)); BackgroundThreads.Add(task); //thread.Start(backgroundJob); } BackgroundManager.StartWorkers(); // starts background timers that process jobs in the queue AddBackgroundInformation("Background jobs", "Background jobs started"); }
public void Dispose() { try { Started = false; BackgroundManager.StopWorkers(); // this call cancellation token . cancel //if (BackgroundThreads != null) //{ // foreach (var t in BackgroundThreads) // { // //if (t.IsAlive) // //{ // // t.Abort(); // //} // if (t != null) // { // t.c // } // } //} } catch (Exception e) { AddBackgroundError("dispose of background service", e); } }
/// <summary> /// This methods runs for each registered background process and either runs it or adds it to the queue of jobs to run. /// This runs an infinite while loop for all background events and sleeps the amount of time determined by CalculateNextRunTime. /// Then it either executes the event or adds it to the queue of jobs to be done. /// The difference is that the first will wait for the result before sleeping the time allocated. /// Whereas the second will schedule the job as soon as it is done sleeping. /// </summary> /// <param name="jobObject"></param> private async Task RunBackgroundEventLoop(object jobObject) { //AddBackgroundInformation("Background jobs", "Background work 1"); var job = (BackgroundJob)jobObject; job.EventNumber = job.Event.GetEventId(); var firstTime = true; BackgroundWorker worker = null; if (job.Event.RunSynchronously == true) { worker = new BackgroundWorker(this); } while (true) { if (firstTime && job.Event.RunImmediatelyFirstTime) { firstTime = false; } else { /* First calculate the amount of time to wait before doing work */ job.NextRunTime = job.Event.CalculateNextRunTime(job.LastRunTime); //TODO: This might not be what we want. // The next run time might depend on the result of previous run AddBackgroundInformation(job.Event.Description, String.Format("Background process {0} is going to sleep until {1}", job.Event.Description, job.NextRunTime)); var sleepTime = job.NextRunTime.Subtract(DateTime.Now); /* Do this after adding background info because it takes time too */ if (sleepTime < TimeSpan.FromSeconds(0)) { sleepTime = TimeSpan.FromMinutes(1); } Thread.Sleep(sleepTime); } job.LastRunTime = DateTime.Now; if (BackupService.BusyWithBackups == true) { continue; } if (job.Event.RunSynchronously == true) { await worker.DoWork(job, CancelToken); } else { BackgroundManager.AddJobToQueue(job); } } }
public BackgroundService(DataService dataService, UserContext userContext, BackgroundManager manager) { DataService = dataService; UserContext = userContext; BackgroundManager = manager; CancelToken = BackgroundManager.Token; if (Started == false) { Setup(); } }
async Task Run(CancellationToken token) { //Logger.Info("Running background worker " + Thread.CurrentThread.ManagedThreadId); while (true) { //Logger.Info("WaitOne in " + Thread.CurrentThread.ManagedThreadId); BackgroundManager.MainEvent.WaitOne(); //Logger.Info("WaitOne passed in" + Thread.CurrentThread.ManagedThreadId); if (token.IsCancellationRequested) { //Logger.Info("Cancellation token received for " + Thread.CurrentThread.ManagedThreadId); token.ThrowIfCancellationRequested(); // sets task status to cancel break; // or sets task as RanToCompletion (i like this option). } //object item; //Logger.Info("Dequeing background job " + Thread.CurrentThread.ManagedThreadId); var backgroundJob = BackgroundManager.Dequeue(); if (backgroundJob == null) { //Logger.Info("Background job is null for " + Thread.CurrentThread.ManagedThreadId); break; } while (backgroundJob != null) { //Thread.Sleep(1000); //Console.WriteLine("Main event doing work 1 time - " + Thread.CurrentThread.ManagedThreadId); if (backgroundJob != null) { //Logger.Info("Doing work in " + Thread.CurrentThread.ManagedThreadId + " for " + backgroundJob.Event.Description); await DoWork(backgroundJob, token); backgroundJob = BackgroundManager.Dequeue(); } else { //Console.WriteLine("Thread " + Thread.CurrentThread.ManagedThreadId + " got nothing"); } } } }