Time synchronization in java

Question

Hi there!

Inside a for-loop I'm controlling the simulation-step-based traffic simulator SUMO by retrieving and processing information of vehicles. To make sure that my program simulates in "real-time" (1 simulation-step = 1 second) I want to sleep my program after the processing phase until the next time step begins. To get better results I'm calculating the time stamp based on a initially taken reference time stamp.

The loop looks like this:

 System.out.println("start of traffic simulation ...");

 for (int i = 0; i < stepCount; i++)
 {
  System.out.println("step: " + i);

  // set before timeStamp
  beforeTimeStamp = System.currentTimeMillis();

  if (firstStep)
  {
   // get reference timeStamp
   referenceTimeStamp = beforeTimeStamp;
   firstStep = false;
  }
  else
  {
   // get next vehicleVector
   vehicleVector = masterControl.traCIclient.simulateStep();
  }

        // process vehicleVector

  // set after timeStamp
  afterTimeStamp = System.currentTimeMillis();

  processingTime = afterTimeStamp - beforeTimeStamp;

  // calculate sleepTime
  sleepTime = referenceTimeStamp + ((i + 1) * 1000) - afterTimeStamp;

       // sleep for sleepTime ms
       Thread.sleep(sleepTime);
 }

 System.out.println("end of traffic simulation ...");

Here's the output of some variables:

step:   0                                                                                                         
beforeTimeStamp 1252317242565                                                                                   
reference time: 1252317242565                                                                                   
processing time: 394                                                                                            
test time: 1252317243565                                                                                        
afterTimeStamp 1252317242959                                                                                    
sleepTime: 606                                                                                                  
step: 1                                                                                                         
beforeTimeStamp 1252317242961                                                                                   
processing time: 665                                                                                            
test time: 1252317244565                                                                                        
afterTimeStamp 1252317243626                                                                                    
sleepTime: 939 (exspected: 1000 - 665 = 335)                                                                                                  

As you can see the sleep time is only correct for the first simulation step. I have no clue what might me going wrong here. Does anybody has an idea?

BR,

Markus

Answer 1

Why not sleep for 1000 - processingTime ? It would be the closest you can get to a correct answer.

Your solution only works on the first step because it's only correct for the first step. You assume that you will start your processing for each step at referenceTime + (step * 1000), but you are not taking overhead (thread sleeping, prints, garbage collection) into account. Print out referenceTimeStamp + ((i + 1) * 1000) - beforeTimeStamp to see what I mean

Answer 2

As highlighted by others, you should be sleeping for 1000 - processing time.

Ignoring the fact that Java SE doesn't provide a real-time platform (and as such you won't get precision), I would perhaps take a look at the Timer class, and particularly Timer.scheduleAtFixedRate(), which will look after scheduling tasks at regular intervals.

Answer 3

There is a simple standard solution in Java starting with Java 5.

Take a look at ScheduledExecutorService.

It will look something like this:

        ScheduledExecutorService service = Executors.newScheduledThreadPool(1);
        service.scheduleAtFixedRate(new MyCode(), 0, 1, TimeUnit.SECONDS);

Where MyCode class implements runnable interface and will be executed once a second.

This is not a real time guarantee but should be sufficient for your case.

Answer 4

Are you sure the output is from the same program? See the discrepancy highlighted inline,

step:   0                                                                                                         
beforeTimeStamp 1252317242565                                                                                   
reference time: 1252317242565                                                                                   
processing time: 394                                                                                            
test time: 1252317243565                                                                                        
afterTimeStamp 1252317242959                                                                                    
sleepTime: 606 #### It didn't sleep this long at all
step: 1                                                                                                         
beforeTimeStamp 1252317242961 #### This is only 2ms from last afteTimeStamp                                                                                 
processing time: 665                                                                                            
test time: 1252317244565                                                                                        
afterTimeStamp 1252317243626                                                                                    
sleepTime: 939 (exspected: 1000 - 665 = 335)  #### This is to make up the deficit from last sleep

There were 604 (606-2) deficit in fist sleep. So 939 (335 + 604) is the correct sleep time for second loop.

Java's sleep is not accurate but it can't be this far off. I think either you interrupt the program in a debugger or the code doesn't match the output.