Java.Timer temporizador. TaskQueue principio para resolver []

empaquetar com.will.learn.quartz; 

importación java.util.Arrays;
importación java.util.TimerTask; 

/ ** 
 * Esta clase representa una cola de tareas de cronómetros: una cola de prioridad de TimerTasks, 
 * ordenada en nextExecutionTime. Cada objeto Timer tiene uno de estos, los que 
 * comparte con su TrenzadoTemporizador. Internamente esta clase utiliza una pila, que 
 * Ofrece registro de rendimiento (n) para el complemento, removeMin y rescheduleMin 
 * operaciones, y el rendimiento constante de tiempo para la operación getMin. 
 * / 
Clase TaskQueue {
     / ** 
     * cola de prioridad representada como una pila binaria equilibrada: los dos niños
     * De cola de [n] son cola [2 * n] y la cola de [2 * n + 1]. La cola de prioridad se
     * Ordenada en el campo nextExecutionTime: El TimerTask con el más bajo 
     * nextExecutionTime es en cola de [1] (suponiendo que la cola es no vacío). Para 
     * cada nodo n en el montón, y cada descendiente de n, d, 
     * n.nextExecutionTime <= d.nextExecutionTime. 
     * / 
    Privada TimerTask [] = cola de nuevo TimerTask [128 ]; 

    / ** 
     * El número de tareas en la cola de prioridad. (Las tareas se almacenan en 
     * cola de [1] hasta cola [tamaño]). 
     * / 
    Privada  int size = 0 ; 

    / ** 
     * Devuelve el número de tareas actualmente en la cola. 
     * / 
    Int size () {
         retorno tamaño; 
    } 

    / ** 
     * Añade una nueva tarea a la cola de prioridad. 
     * / 
    Void add (tarea TimerTask) {
         // Grow almacén de respaldo si es necesario 
        si (tamaño + 1 == queue.length) 
        cola = Arrays.copyOf (cola, 2 * queue.length); 

        cola [ ++ tamaño] = tarea; 
        Fixup (tamaño); 
    } 

    / ** 
     * Devuelve la "tarea cabeza" de la cola de prioridad. (La tarea principal es una 
     tarea * nextExecutionTime con el más bajo).
      * / 
    TimerTask getMin () { 
        retorno cola de [1 ]; 
    } 

    / **
     * Retorno la tarea i-ésima en la cola de prioridad, donde i varía de 1 (la 
     tarea cabeza *, que se devuelve por getMin) para el número de tareas en la 
     cola *, inclusive. 
     * / 
    TimerTask get ( int i) {
         retorno de colas [i]; 
    } 

    / ** 
     * Eliminar la tarea cabeza de la cola de prioridad. 
     * / 
    Void removeMin () { 
        cola de [ 1] = cola [tamaño]; 
        cola [tamaño -] = nulo ;  //Caída de referencia adicional para prevenir fugas de memoria 
        fixDown (1 ); 
    } 

    / ** 
     * Elimina el i-ésimo elemento de la cola sin tener en cuenta para mantener 
     * el invariante montón. Recordemos que la cola es uno a base de, por lo 
     * 1 <= i <= tamaño. 
     * / 
    Void quickRemove ( int i) {
         assert i <= tamaño; 

        cola de [i] = cola [tamaño]; 
        cola [tamaño -] = nulo ;  // gota ref adicional para prevenir pérdida de memoria 
    } 

    / ** 
     * Establece el nextExecutionTime asociados con la tarea a la cabeza 
     * valor especificado, y ajusta cola de prioridad en consecuencia. 
     * / 
    Void rescheduleMin ( largo Newtime) { 
        cola de [ 1] .nextExecutionTime = Newtime; 
        fixDown ( 1 ); 
    } 

    / ** 
     * Devuelve true si la cola de prioridad no contiene elementos. 
     * / 
    Boolean estaVacia () {
         retorno tamaño == 0 ; 
    } 

    / ** 
     * Elimina todos los elementos de la cola de prioridad. 
     * / 
    Void clear () {
         // Null las referencias de tareas para prevenir pérdida de memoria 
        para ( int i = 1; i <= tamaño; i ++ ) 
            cola de [i] = nulo ; 

        tamaño = 0 ; 
    } 

    / **
     * Establece el invariante montón (descrito anteriormente) suponiendo el montón 
     * satisface la invariantes excepto, posiblemente, para la hoja-nodo indexado por k 
     * (que puede tener un nextExecutionTime menos de su matriz de). 
     * 
     * Este funciones método por el "promover" cola de [k] en la jerarquía 
     * (intercambiando con su matriz) varias veces hasta que la cola de [k] 's 
     * nextExecutionTime es mayor que o igual a la de su padre. 
     * / 
    Privada  nula corrección ( int k) {
         tiempo (k> 1 ) {
             int j = k >> 1 ;
            si (cola [j] .nextExecutionTime <=cola de [k] .nextExecutionTime)
                 descanso ; 
            TimerTask tmp = cola [j]; cola de [j] = cola de [k]; cola de [k] = tmp; 
            k = j; 
        } 
    } 

    / ** 
     * Establece el invariante montón (descrito anteriormente) en el subárbol 
     * raíz en k, que se supone para satisfacer la invariante montón excepto 
     * posiblemente para propio nodo k (que puede tener un mayor nextExecutionTime 
     * que la de sus hijos). 
     * 
     * Funciones este método "degradar" cola de [k] abajo de la jerarquía
     * (Intercambiando con su niño más pequeño) varias veces hasta que la cola de [k] 's 
     * nextExecutionTime es inferior o igual a los de sus hijos. 
     * / 
    Privada  ;void fixDown ( int k) {
         int j;
        mientras que ((j = k << 1) <= tamaño && j> 0 ) {
             si (j <tamaño && 
                cola [j] .nextExecutionTime > cola [j + 1 ] .nextExecutionTime) 
                j ++; // índices j más pequeño niño 
            si (cola [k] .nextExecutionTime <= cola [j] .nextExecutionTime)
                 romper 
            TimerTask tmp = cola [j]; cola de [j] = cola de [k]; cola de [k] = tmp; 
            k = j; 
        } 
    } 

    / **
     * Establece el invariante montón (descrito anteriormente) en todo el árbol, 
     * asumiendo nada sobre el orden de los elementos antes de la llamada. 
     * / 
    Void heapify () {
         para ( int i = tamaño / 2; i> = 1; i-- ) 
            fixDown (i); 
    } 
}