public TopicWork(ICommentWork commentWork, IBannedWordWork bannedWordWork, IThreadWork threadWork, SettingWork settingWork) { _commentWork = commentWork; _bannedWordWork = bannedWordWork; _threadWork = threadWork; _settingWork = settingWork; _defaultSetting = _settingWork.GetDefaultSetting(); }
public TopicDriver(ITopicWork contentTopicWork, ICommentWork commentWork, ICommentDriver commentDriver, ITagWork tagWork, IThreadWork threadWork) : base(contentTopicWork) { _topicWork = contentTopicWork; _commentWork = commentWork; _commentDriver = commentDriver; _tagWork = tagWork; _threadWork = threadWork; }
public CommentWork(IUploadFileWork uploadWork, IUploadFileCategoryWork uploadCategoryWork, IBannedWordWork bannedWordWork, SettingWork settingWork, ThreadWork threadWork, IRepository <ContentTopic> topicRepository) { _topicRepository = topicRepository; _uploadWork = uploadWork; _uploadCategoryWork = uploadCategoryWork; _bannedWordWork = bannedWordWork; _settingWork = settingWork; _threadWork = threadWork; _defaultSetting = _settingWork.GetDefaultSetting(); }
/// <summary> /// Handles executing the thread work. /// Thread logic: /// While isClickerThreadRunning: /// Wake anyone waiting for us to finish our current job /// Wait for someone to set a new job and wake us up /// Wake anyone waiting for us to confirm that we've recieved a job. /// While threadWork.IsComplete(): /// Execute the job payload /// Wait for either a confirmation to stop working or for a given time limit. /// </summary> private void WorkerThreadLogic() { lock (workerThreadLock) { while (true) { if (!isClickerThreadRunning) { // If clickerThreadRunning flag has been set to false then main is waiting for us to confirm that // this thread has completed (main's waiting on isThreadComplete to be set to true) Utils.OutputLine("Worker: PULSE becuase we're finished", Utils.OutputLevel.Threading); isThreadComplete = true; Monitor.Pulse(workerThreadLock); return; } // Main must wait for 'threadWork' to be set to null before it can schedule more work. Let main know // that we're done with the previous work. Utils.OutputLine("Worker: PULSE we set threadWork to null and we're waiting for work", Utils.OutputLevel.Threading); threadWork = null; Monitor.Pulse(workerThreadLock); while (isClickerThreadRunning && threadWork == null) { // Wait for main to schedule some more work for us *or* for main to stop this thread. Utils.OutputLine("Worker: WAIT for more work...", Utils.OutputLevel.Threading); Monitor.Wait(workerThreadLock); Utils.OutputLine("Worker: RESUME", Utils.OutputLevel.Threading); Utils.OutputLine("Worker: PULSE for acknowledgement that we woke up from the pulse", Utils.OutputLevel.Threading); Monitor.Pulse(workerThreadLock); } Utils.OutputLine("Worker: (debug) " + isClickerThreadRunning + " Threadwork: " + ((threadWork == null) ? "Null" : "Yes"), Utils.OutputLevel.Threading); int retryCount = 0; while (isClickerThreadRunning && threadWork != null && threadWork.IsComplete()) { // Keep executing our payload every 'retryDelayInMs' ms until main tells us to top // executing it. Main must notify us whenever it stops executing. //OutputLine("Execute..."); Utils.OutputLine("Worker: Execute...", Utils.OutputLevel.Threading); threadWork.Execute(retryCount); Utils.OutputLine("Worker: WAIT " + threadWork.GetRetryRate() + "ms", Utils.OutputLevel.Threading); Monitor.Wait(workerThreadLock, threadWork.GetRetryRate()); Utils.OutputLine("Worker: RESUME", Utils.OutputLevel.Threading); ++retryCount; } Utils.OutputLine("Worker: Done executing!", Utils.OutputLevel.Threading); } } }
/// <summary> /// Schedules a job. This function will BLOCK until the previously scheduled job has finished. /// </summary> /// <param name="newWork"></param> public void SetWork(IThreadWork newWork) { lock (workerThreadLock) { Utils.OutputLine("ClickObjectFace: StopThreadWork", Utils.OutputLevel.Game); StopThreadWork(); Utils.OutputLine("ClickObjectFace: PULSE because new threadwork...", Utils.OutputLevel.Threading); threadWork = newWork; Monitor.Pulse(workerThreadLock); Utils.OutputLine("ClickObjectFace: WAIT for thread to start working...", Utils.OutputLevel.Threading); Monitor.Wait(workerThreadLock); Utils.OutputLine("ClickObjectFace: RESUME", Utils.OutputLevel.Threading); } }
/// <summary> /// Kills the thread pool thread if it's running. This function will BLOCK until the thread has /// completed. Must be called prior to shutting down to guarentee a clean exit. /// </summary> public void KillPreviousThread() { if (workerThread == null) { return; } lock (workerThreadLock) { Utils.OutputLine("KillPreviousThread: Previous thread still running, joining it...", Utils.OutputLevel.Game); StopThreadWork(); isClickerThreadRunning = false; Monitor.Pulse(workerThreadLock); while (!isThreadComplete) { Utils.OutputLine("KillPreviousThread: WAIT for thread to end...", Utils.OutputLevel.Threading); Monitor.Wait(workerThreadLock); Utils.OutputLine("KillPreviousThread: RESUME", Utils.OutputLevel.Threading); } threadWork = null; } workerThread.Join(); workerThread = null; }
public ThreadDriver(IThreadWork threadWork) : base(threadWork) { _threadServic = threadWork; }
public PermissionWork(IRepository <Permission> permissionRepository, IThreadWork threadWork) { _permissionRepository = permissionRepository; _threadWork = threadWork; }
public CommentDriver(ICommentWork commentWork, IThreadWork threadWork) : base(commentWork) { _commentWork = commentWork; _threadWordk = threadWork; }