/// <summary> /// Cancels a job if it has not been started already /// </summary> /// <param name="job"></param> public bool CancelJob(BackgroundThreadPoolJob job) { throw new NotImplementedException("Job cancellation is not supported at this time."); // first check in the queue // then check for a running job // return false; }
/// <summary> /// Enqueues a thread pool job to be executed by the thread pool /// </summary> /// <param name="job"></param> public void QueueJob(BackgroundThreadPoolJob job) { // lock the queue lock (this.JobQueue.SyncRoot) { // and enqueue the job to be processed this.JobQueue.Enqueue(job); } }
/// <summary> /// Adds a job to the queue /// </summary> /// <param name="job"></param> public void Enqueue(BackgroundThreadPoolJob job) { if (this.Contains(job)) { throw new BackgroundThreadPoolJobAlreadyQueuedException(job); } lock (base.SyncRoot) { base.Enqueue(job); } }
/// <summary> /// Creates a thread pool job and enqueues it for the thread pool to execute /// </summary> /// <param name="startInfo">The background thread start info that will be executed as a thread pool job</param> /// <returns></returns> public BackgroundThreadPoolJob QueueJob(string name, BackgroundThreadStartInfo startInfo) { // lock the queue lock (this.JobQueue.SyncRoot) { // create a new job BackgroundThreadPoolJob job = new BackgroundThreadPoolJob(name, startInfo); // and enqueue the job to be processed this.JobQueue.Enqueue(job); // return the job that was created and enqueued return(job); } }
/// <summary> /// Determines if the job exists in the queue /// </summary> /// <param name="job"></param> /// <returns></returns> public bool Contains(BackgroundThreadPoolJob job) { lock (base.SyncRoot) { IEnumerator it = base.GetEnumerator(); while (it.MoveNext()) { if (Guid.Equals(((BackgroundThreadPoolJob)it.Current).Id, job.Id)) { return(true); } } return(false); } }
/// <summary> /// Monitors the jobs in the job queue and delegates threads to service the waiting jobs /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void OnProcessJobs(object sender, BackgroundThreadStartEventArgs e) { try { // continuously monitor the job queue and thread count while (true) { // lock the thread list lock (_threads.SyncRoot) { // if we haven't reached the max thread limit if (_threads.Count < _maxThreads) { // lock the job queue lock (this.JobQueue.SyncRoot) { // if there are jobs waiting if (this.JobQueue.Count > 0) { // dequeue the next waiting job BackgroundThreadPoolJob job = this.JobQueue.Dequeue(); // create a new background thread pool thread to process the job BackgroundThreadPoolThread thread = new BackgroundThreadPoolThread(job); // and finally add the thread to our list of threads _threads.Add(thread); } } } this.DestroyThreads(true /* only the finished ones */); } Thread.Sleep(100); } } catch (ThreadAbortException) { // the processing thread is aborting } catch (Exception ex) { Log.WriteLine(ex); } }
/// <summary> /// Initializes a new instance of the BackgroundThreadPoolThread class /// </summary> /// <param name="job"></param> internal BackgroundThreadPoolThread(BackgroundThreadPoolJob job) : base() { if (job == null) throw new ArgumentNullException("job"); _job = job; // wire the job's start info to the thread events base.Run += _job.StartInfo.Run; if (_job.StartInfo.Finished != null) base.Finished += _job.StartInfo.Finished; // determine if the thread will allow ThreadAbortExceptions to be throw //base.AllowThreadAbortException = _job.StartInfo.AllowThreadAbortExceptions; // start the thread automatically base.Start(true, _job.StartInfo.Args); }
/// <summary> /// Initializes a new instance of the BackgroundThreadPoolThread class /// </summary> /// <param name="job"></param> internal BackgroundThreadPoolThread(BackgroundThreadPoolJob job) : base() { if (job == null) { throw new ArgumentNullException("job"); } _job = job; // wire the job's start info to the thread events base.Run += _job.StartInfo.Run; if (_job.StartInfo.Finished != null) { base.Finished += _job.StartInfo.Finished; } // determine if the thread will allow ThreadAbortExceptions to be throw //base.AllowThreadAbortException = _job.StartInfo.AllowThreadAbortExceptions; // start the thread automatically base.Start(true, _job.StartInfo.Args); }
/// <summary> /// Enqueues a thread pool job to be executed by the thread pool /// </summary> /// <param name="job"></param> public void QueueJob(BackgroundThreadPoolJob job) { // lock the queue lock (this.JobQueue.SyncRoot) { // and enqueue the job to be processed this.JobQueue.Enqueue(job); } }
/// <summary> /// Initializes a new instance of the BackgroundThreadPoolJobAlreadyFinishedException class /// </summary> /// <param name="job">The job that already finished</param> internal BackgroundThreadPoolJobAlreadyFinishedException(BackgroundThreadPoolJob job) : base("The job has already finished. A job cannot be cancelled after it has already finished.") { _job = job; }
/// <summary> /// Initializes a new instance of the BackgroundThreadPoolJobAlreadyFinishedException class /// </summary> /// <param name="job">The job that already finished</param> internal BackgroundThreadPoolJobAlreadyFinishedException(BackgroundThreadPoolJob job) : base("The job has already finished. A job cannot be cancelled after it has already finished.") { _job = job; }
/// <summary> /// Cancels a job if it has not been started already /// </summary> /// <param name="job"></param> public bool CancelJob(BackgroundThreadPoolJob job) { throw new NotImplementedException("Job cancellation is not supported at this time."); // first check in the queue // then check for a running job // return false; }
/// <summary> /// Determines if the job exists in the queue /// </summary> /// <param name="job"></param> /// <returns></returns> public bool Contains(BackgroundThreadPoolJob job) { lock (base.SyncRoot) { IEnumerator it = base.GetEnumerator(); while(it.MoveNext()) { if (Guid.Equals(((BackgroundThreadPoolJob)it.Current).Id, job.Id)) { return true; } } return false; } }
/// <summary> /// Initializes a new instance of the BackgroundThreadPoolJobAlreadyQueuedException class /// </summary> /// <param name="job">The job that is already queued</param> internal BackgroundThreadPoolJobAlreadyQueuedException(BackgroundThreadPoolJob job) : base("The job is already queued. A job cannot be queued more than one time if the previous queued job is still waiting to be executed.") { _job = job; }
/// <summary> /// Initializes a new instance of the BackgroundThreadPoolJobAlreadyQueuedException class /// </summary> /// <param name="job">The job that is already queued</param> internal BackgroundThreadPoolJobAlreadyQueuedException(BackgroundThreadPoolJob job) : base("The job is already queued. A job cannot be queued more than one time if the previous queued job is still waiting to be executed.") { _job = job; }
/// <summary> /// Adds a job to the queue /// </summary> /// <param name="job"></param> public void Enqueue(BackgroundThreadPoolJob job) { if (this.Contains(job)) throw new BackgroundThreadPoolJobAlreadyQueuedException(job); lock (base.SyncRoot) { base.Enqueue(job); } }
/// <summary> /// Creates a thread pool job and enqueues it for the thread pool to execute /// </summary> /// <param name="startInfo">The background thread start info that will be executed as a thread pool job</param> /// <returns></returns> public BackgroundThreadPoolJob QueueJob(string name, BackgroundThreadStartInfo startInfo) { // lock the queue lock (this.JobQueue.SyncRoot) { // create a new job BackgroundThreadPoolJob job = new BackgroundThreadPoolJob(name, startInfo); // and enqueue the job to be processed this.JobQueue.Enqueue(job); // return the job that was created and enqueued return job; } }