示例#1
0
        /// <summary>
        /// Método que se ejecuta en segundo plano para procesar la cola
        /// </summary>
        /// <param name="token">Token con los datos de la ejecución</param>
        /// <returns>Nulo</returns>
        private object RunProcessContext(Token <int> token)
        {
            while (_workers.Count > 0)
            {
                long idProcess = WorkUtils.AddWork(
                    _workers.Dequeue(), _workersForceExecutions.Dequeue());

                Hal.WaitEnd(idProcess);
            }

            return(null);
        }
示例#2
0
        /// <summary>s
        /// Ejecuta un proceso en segundo plano o lo coloca en la cola de ejecución
        /// en caso de no quedar ningún hilo libre
        /// </summary>
        /// <typeparam name="T">Tipo de parámetro del delegado a invocar</typeparam>
        /// <param name="sticky">Plan de ejecución</param>
        /// <param name="forceExecution">Indica que se ejecuta sin tener en cuenta el número de procesos en ejecución</param>
        /// <param name="exeCxt">Contexto de ejecución </param>
        /// <returns>Identificador del plan de ejecución</returns>
        public static long AddWork <T>(Sticky <T> sticky, bool forceExecution, ExecutionContext <T> exeCxt)
        {
            //Iniciamos el sonar si no estaba activo
            if (Hal.Sonar == null)
            {
                Thread.CurrentThread.Priority = ThreadPriority.AboveNormal;

                Hal.Sonar   = new Dictionary <long, BackgroundWorker>(Hal.MaxParallelsProcess + 5);
                Hal.Results = new Dictionary <long, object>(Hal.MaxParallelsProcess + 5);

                SonarProgress = new Dictionary <long, int>();
                SonarCache    = new Dictionary <string, object>();

                ProcessInQueue      = new Queue <object>();
                ProcessInQueueIndex = new List <long>();

                CacheDependencies = new Dictionary <string, IList <long> >();
                IndexDependencies = new Dictionary <string, string>();
            }

            if (exeCxt != null)
            {
                exeCxt.AttachWork(sticky, forceExecution);
                return(-1);
            }

            //Asignamos un ticket de ejecución al trabajo
            sticky.Id = Hal.GetTicket();

            //Creamos el trabajo y lo ejecutamos si no excede
            //el limite de hilos en ejecución o es prioritario
            if (Hal.Sonar.Count < Hal.MaxParallelsProcess || forceExecution)
            {
                RunWork(sticky);
            }
            else
            {
                //Si hay demasiados trabajos en paralelo
                //se encola para su futura ejecución
                ProcessInQueue.Enqueue(sticky);
                ProcessInQueueIndex.Add(sticky.Id);
            }

            return(sticky.Id);
        }