Esempio n. 1
0
        public static Thread QueueUserWorkItem(Delegate func, params object[] args)
        {
            if (ms_funcThreadWorker == null)
            {
                ms_funcThreadWorker = (WaitCallback)ThreadWorker;
            }

            while (numThreads >= maxThreads)
            {
                Thread.Sleep(1);
            }

            Interlocked.Increment(ref numThreads);
            try
            {
                //如果线程不够了,就直接执行
                var state = new ThreadTaskState()
                {
                    args = args, func = func
                };
                System.Threading.ThreadPool.QueueUserWorkItem((WaitCallback)(ms_funcThreadWorker), state);
            }
            catch (Exception e)
            {
                ((Action <object[]>)func)(args);
                Interlocked.Decrement(ref numThreads);
            }
            finally
            {
            }

            return(null);
        }
Esempio n. 2
0
        private void OnUpdate()
        {
            try
            {
                while (!_isQuitRequest)
                {
                    while (_state != ThreadTaskState.Busy)
                    {
                        _event.WaitOne();
                    }

                    if (_context != null)
                    {
                        _dispose.Invoke(ref _context);
                    }

                    _state = ThreadTaskState.Done;
                }
            }
            catch (Exception e)
            {
                _except = e;
            }
            finally
            {
                _state = ThreadTaskState.Quit;
            }
        }
Esempio n. 3
0
        public ThreadTask(ThreadUpdateDelegate callback)
        {
            _state         = ThreadTaskState.Idle;
            _isQuitRequest = true;

            _dispose = callback;
            _event   = new AutoResetEvent(false);
            _thread  = new Thread(OnUpdate);
        }
Esempio n. 4
0
 public void Start()
 {
     if (_isQuitRequest)
     {
         _except        = null;
         _isQuitRequest = false;
         _state         = ThreadTaskState.Idle;
         _thread.Start();
     }
 }
Esempio n. 5
0
 public static void QueueOnMainThread(Delegate func, params object[] args)
 {
     lock (ms_listFuncOnMainThread)
     {
         var state = new ThreadTaskState()
         {
             args = args, func = func
         };
         ms_listFuncOnMainThread.Add(state);
     }
 }
Esempio n. 6
0
        public void Dispose()
        {
            if (!_isQuitRequest)
            {
                _isQuitRequest = true;

                _state   = ThreadTaskState.Busy;
                _context = null;
                _event.Set();
                _thread.Join();
                _state = ThreadTaskState.Quit;
            }
        }
Esempio n. 7
0
 public void Respond(ThreadTaskDelegate taskDelegate)
 {
     try
     {
         Response = taskDelegate(this);
         State    = ThreadTaskState.Responded;
     }
     catch (Exception e)
     {
         Error = e;
         State = ThreadTaskState.Error;
     }
     ResetEvent.Set();
 }
Esempio n. 8
0
        private static void ThreadWorker(object obj)
        {
            try
            {
                ThreadTaskState state = obj as ThreadTaskState;

                ((Action <object[]>)state.func)(state.args);
            }
            catch
            {
            }
            finally
            {
                Interlocked.Decrement(ref numThreads);
            }
        }
Esempio n. 9
0
 public void Task(ThreadData data)
 {
     _context = data;
     _state   = ThreadTaskState.Busy;
     _event.Set();
 }