예제 #1
0
        /// <summary>
        /// This function serves as a callback method for queueing threads and
        ///  when they complete.
        /// </summary>
        /// <param name="name">The name of the thread that is finished working.</param>
        void threadCallback(string name = "")
        {
            lock (m_Lock)
            {
                if (name != null)
                {
                    if (m_ActiveThreads.ContainsKey(name))
                    {
                        //decrement active threads and cleanup
                        BaseWorker finishedThread = m_ActiveThreads[name];

                        m_ActiveThreads.Remove(name);
                        m_DeadThreads.Add(finishedThread);
                    }
                    else
                    {
                        Console.WriteLine("Error: No Active threads with the name: " + name);
                    }
                }
                else
                {
                    Console.WriteLine("Error: Thread name is not valid.");
                }
            }
        }
예제 #2
0
 protected void setActiveThreads()
 {
     while (m_Run)
     {
         DateTime start = DateTime.Now;
         if ((m_ActiveThreads.Count() < m_MaxThreads) && (m_ThreadQueue.Count > 0)
             )
         {
             lock (m_Lock)
             {
                 start = DateTime.Now;
                 while (m_ActiveThreads.Count() < m_MaxThreads &&
                        m_ThreadQueue.Count() > 0 &&
                        DateTime.Now - start < TimeSpan.FromSeconds(2))
                 {
                     //pop a thread and start, and increment active threads
                     BaseWorker popThread = m_ThreadQueue[0];
                     m_ThreadQueue.RemoveAt(0);
                     if (popThread != null &&
                         !m_ActiveThreads.ContainsKey(popThread.ThreadId.ToString()))
                     {
                         m_ActiveThreads[popThread.ThreadId.ToString()] = popThread;
                         if (popThread.ThreadState == System.Threading.ThreadState.Unstarted)
                         {
                             popThread.Start();
                         }
                     }
                 }
             }
         }
         Thread.Sleep(120);
     }
 }
예제 #3
0
        public void start()
        {
            BaseWorker th = new BaseWorker(runThreadsLoop);

            th.Name = "Main Thread Loop";
            th.createThread(ref th);
            th.Start();
        }
예제 #4
0
        /// <summary>
        /// This function will create a thread for the worker.
        ///
        /// This is a child thread of a main worker thread.  So
        /// it passes all the attributes of the parent thread to
        /// the child thread.
        /// </summary>
        /// <param name="worker">The worker thread to create a thread for.</param>
        /// <returns>The created thread.</returns>
        public void createThread(ref BaseWorker worker)
        {
            if (worker != this)
            {
                worker.queueCallback    = queueCallback;
                worker.threadCallback   = threadCallback;
                worker.progressCallback = progressCallback;
                worker.m_HistoryId      = this.m_HistoryId;
                worker.m_UserId         = this.m_UserId;
                worker.Params           = this.Params;
                //worker.setProc(this.m_Proc);
            }

            if (progressCallback != null)
            {
                progressCallback(worker.m_HistoryId, ThreadManager.ThreadProcessState.ADDED);
            }

            Thread thread = null;

            if (worker.m_SimpleMethod != null)
            {
                thread = new Thread(worker.doWork);
            }
            else if (worker.m_ParamMethod != null)
            {
                ParameterizedThreadStart pts = new ParameterizedThreadStart(worker.doWorkP);
                thread = new Thread(pts);
            }

            if (thread != null)
            {
                thread.SetApartmentState(ApartmentState.STA);

                String name = m_ThreadIdName;
                if (String.IsNullOrEmpty(name))
                {
                    name = this.GetType().ToString();
                }
                thread.Name = name + "-" + thread.ManagedThreadId;
                if (String.IsNullOrEmpty(worker.m_ThreadIdName))
                {
                    worker.m_ThreadIdName = thread.Name;
                }
                else
                {
                    worker.m_ThreadIdName += "-" + thread.ManagedThreadId;
                }
                if (thread.Name.Length == 0)
                {
                    Console.WriteLine("No name Thread.");
                }

                worker.setThread(thread);
            }
        }
예제 #5
0
 /// <summary>
 /// This function serves as a callback method for queueing threads and
 ///  when they complete.
 /// </summary>
 /// <param name="thread">A handle to the worker thread.</param>
 void queueCallback(BaseWorker thread)
 {
     lock (m_Lock)
     {
         //if worker isn't null then add thread to queue
         if (thread != null)
         {
             m_ThreadQueue.Add(thread);
         }
     }
 }
예제 #6
0
        /// <summary>
        /// This function will take in a worker instance object, a callback handle, and
        ///  a social media type.  Then it will create and queue a thread for running.
        /// </summary>
        /// <param name="worker">The worker instance object.</param>
        public void createQueueThread(BaseWorker worker)
        {
            //create worker thread
            m_TotalThreads++;
            worker.queueCallback    += new BaseWorker.queueCallbackDelegate(queueCallback);
            worker.threadCallback   += new BaseWorker.threadCallbackDelegate(threadCallback);
            worker.progressCallback += new BaseWorker.progressCallbackDelegate(progressCallback);
            worker.m_SeedThread      = true;

            worker.createThread(ref worker);

            lock (m_Lock)
            {
                //queue thread
                m_ThreadQueue.Add(worker);
            }
        }
예제 #7
0
 // Pause all requested cancel threads
 protected void setCancelledThreads()
 {
     while (m_Run)
     {
         DateTime start = DateTime.Now;
         for (int i = 0;
              i < m_CancelThreads.Keys.Count &&
              DateTime.Now - start < TimeSpan.FromSeconds(2);
              i++)
         {
             long uid = m_CancelThreads.Keys.ElementAt <long>(i);
             long hid = m_CancelThreads[uid];
             for (int b = 0;
                  b < m_ActiveThreads.Count &&
                  DateTime.Now - start < TimeSpan.FromSeconds(2);
                  b++)
             {
                 String     key = m_ActiveThreads.Keys.ElementAt <String>(b);
                 BaseWorker th  = m_ActiveThreads[key];
                 if (false)
                 {
                     th.Stop();
                 }
             }
             for (int n = 0;
                  n < m_ThreadQueue.Count &&
                  DateTime.Now - start < TimeSpan.FromSeconds(2);
                  n++)
             {
                 BaseWorker th = m_ThreadQueue[n];
                 if (false)
                 {
                     m_ThreadQueue.RemoveAt(n);
                     n--;
                 }
             }
             m_CancelThreads.Remove(uid);
         }
         Thread.Sleep(120);
     }
 }
예제 #8
0
        /// <summary>
        /// This function serves as the master run thread loop.
        /// </summary>
        public void runThreadsLoop()
        {
            DateTime   printStatusTime = DateTime.Now;
            int        count           = 0;
            BaseWorker cancelTh        = new BaseWorker(this.setCancelledThreads);

            cancelTh.Name = "setCancelledThreads";
            cancelTh.createThread(ref cancelTh);
            cancelTh.Start();
            BaseWorker activeTh = new BaseWorker(this.setActiveThreads);

            activeTh.Name = "setActiveThreads";
            activeTh.createThread(ref activeTh);
            activeTh.Start();
            BaseWorker maxTh = new BaseWorker(this.setMaxThreads);

            maxTh.Name = "setMaxThreads";
            maxTh.createThread(ref maxTh);
            maxTh.Start();
            BaseWorker gcTh = new BaseWorker(this.gcCleanup);

            gcTh.Name = "gcCleanup";
            gcTh.createThread(ref gcTh);
            gcTh.Start();

            // maybe create 3 threads to manage the arrays.
            while (m_Run)
            {
                DateTime start            = DateTime.Now;
                int      completedThreads = 0;

                if (DateTime.Now - printStatusTime > TimeSpan.FromSeconds(5) &&
                    (m_DeadThreads.Count > 0 || m_ActiveThreads.Count > 0))
                {
                    start = DateTime.Now;
                    for (int i = 0;
                         i < m_DeadThreads.Count &&
                         DateTime.Now - start < TimeSpan.FromSeconds(2);
                         i++)
                    {
                        if (m_DeadThreads[i] == null ||
                            m_DeadThreads[i].Join(150))
                        {
                            //m_DeadThreads[i] = null;
                            m_DeadThreads.RemoveAt(i);
                            //Console.Write(".");
                            i--;
                            completedThreads++;
                        }
                    }
#if DEBUG
                    Console.WriteLine(m_InstanceName + "\n" +
                                      "Added Threads: " + m_TotalThreads +
                                      "\nQueued Threads: " + m_ThreadQueue.Count +
                                      "\nActive Threads: " + m_ActiveThreads.Count +
                                      "\nCompleted Threads: " + completedThreads +
                                      "\nDead Threads: " + m_DeadThreads.Count +
                                      "\nMax Threads: " + m_MaxThreads +
                                      "\nRequested Threads: " + MaxThreads);
                    m_TotalThreads   = 0; // added threads
                    completedThreads = 0;
#endif
                    printStatusTime = DateTime.Now;
                }
                else
                {
                    if (m_ActiveThreads.Count > m_MaxThreads)
                    {
                        Thread.Sleep(120);
                    }
                    //else
                    //    Thread.Sleep(300);
                }
                Thread.Sleep(120);
            }

            //update history to complete
            Console.WriteLine("All threads complete, press any key to continue.");
        }