在Java中调度两个独立的定时器并改变一个定时器的周期

Question

我在java中有两个独立调度的定时器。两个计时器都有不同的任务。

定时器1递增一个数字，定时器2改变定时器1的周期。这是我使用两个定时器的代码

public class Receiver 
{ 
     public static int               totalBufferCapacity     = 1024; 
     public static int               totalPacketsDropped     = 0; 
     public static int               totalPacketsServiced    = 0; 
     public static int               totalPacketsReceived    = 0; 
     public static int               timesBufferGetsFull     = 0; 
     public static int               timesIntervelChanged    = 0; 

     public static Socket            clientSocket; 
     public static BufferedReader    br; 
     public static ArrayList<String>   buffer; 

     public static String            START                   = "Start"; 
     public static String            STOP                    = "Stop"; 
     public static String            token                   = "1"; 
     public static boolean           flag; 

     public static Timer             timer; 

     public static int               Max                     = 80; 
     public static int               Min                     = 40; 

     public static int               rand; 
     public static PrintStream       ps; 
     public static String            packet; 
     public static Timer             timer_2; 
     public static consumeArrayItems task; 


     public static void main(String[] args) 
    { 
        flag = true; 
        try
        { 
           init(args[0], args[1]); 

           while (flag) 
           { 
              storePacketInArray(); 
           } 

        } catch (Exception e) 
        { 
             e.printStackTrace(); 
        } 
    } 


    public static void init(String localHost, String portNumber) 
    { 
        try
        { 

            // inet address which is local host in this case 
            InetAddress acceptorHost = InetAddress.getByName(localHost); 

            // port number at which the sender wants to communicate 
            int serverPortNum = Integer.parseInt(portNumber); 

            clientSocket = new Socket(acceptorHost, serverPortNum); 

         } catch (IOException e) 
         { 
             e.printStackTrace(); 

         } 
    } 



     public static void storePacketInArray() 
     { 
          try
          { 
             if (br == null) 
             { 
                  br = new BufferedReader(new InputStreamReader(clientSocket.getInputStream())); 
             } 

           packet = new String(br.readLine()); 

           if (packet.compareToIgnoreCase("Start") == 0) 
           { 
                 token = START; 
                 buffer = new ArrayList<String>(totalBufferCapacity); 
           } else if (packet.compareToIgnoreCase("Stop") == 0) 
           { 
                 stopVaryingTimeSchedular(); 
                 stopSchedular(); 
           } else
           { 
                 totalPacketsReceived += 1; 
                 buffer.add(packet); 
           } 


           computeToken(); 

        } catch (IOException e) 
        { 
            e.printStackTrace(); 

        } 
     } 


    public static void computeToken() 
    { 
        int bufferSize = buffer.size(); 

        if (bufferSize > 0 && bufferSize < totalBufferCapacity) 
        { 
             float queueOccupancy = (bufferSize * 100 / totalBufferCapacity); 


        } else if (bufferSize == totalBufferCapacity) 
        { 
             token = "10"; 
             timesBufferGetsFull += 1; 
        } else if (token.compareToIgnoreCase("Start") == 0) 
        { 
             token = START; 
             startSchedular(); 
             startVaryingTimeSchedular(); 

         } else
        { 
              totalPacketsDropped += 1; 
              token = "15"; 

        } 


        sendAcknowledgment(); 

     } 



     public static void sendAcknowledgment() 
    { 

         try
         { 
             if (ps == null) 
             { 
                 ps = new PrintStream(clientSocket.getOutputStream()); 
             } 

             String tokenAck = token; 

             if (packet.compareToIgnoreCase("Stop") != 0) 
             { 
                 ps.println(tokenAck); 
                 ps.flush(); 
             } 
             if (!flag) 
             { 
                 clientSocket.close(); 
             } 

         } catch (IOException e) 
         { 
              e.printStackTrace(); 
         } 

    } 


     public static void startSchedular() 
     { 

          rand = (int) (Math.random() * (Max - Min)); 
          timer = new Timer(); 
          task = new consumeArrayItems(true); 
          timer.scheduleAtFixedRate(task, 1, rand); 
     } 

     public static void stopSchedular() 
     { 
         timer.cancel(); 
         timer.purge(); 
         flag = false; 

     } 

      // After every 500 ms service time of packets will vary between Max and Min 
     public static void startVaryingTimeSchedular() 
     { 
         timer_2 = new Timer(); 
         timer_2.scheduleAtFixedRate(new varyServiceTime(), 0, 500); 
     } 

     public static void stopVaryingTimeSchedular() 
     { 

         timer_2.cancel(); 
         timer_2.purge(); 
     } 

  } 


 class consumeArrayItems extends TimerTask 
 { 


       public synchronized void run() 
       { 
          if (Receiver.buffer.size() > 0) 
          { 
              Receiver.totalPacketsServiced += 1; 
              Receiver.buffer.remove(Receiver.buffer.size() - 1); 
          } 
       } 
  } 

  class varyServiceTime extends TimerTask 
  { 

        public synchronized void run() 
        { 
              Receiver.timer.cancel(); 
              Receiver.timer = null; 
              Receiver.rand = (int) (Math.random() * (Receiver.Max - Receiver.Min)); 
              Receiver.timer = new Timer(); 
              Receiver.timer.scheduleAtFixedRate(new consumeArrayItems(), 0,Receiver.rand); 

              Receiver.timesIntervelChanged += 1; 
        } 
  } 

计时器2永远不会被安排。我在这做什么错。