I'd say there are at least two options, see below. The first is probably faster, especially with a lot of objects, cause it requires less re-calculation. But in some circumstances the second may be more useful.

1. Have a global time variable that is incremented at the same time as the individual object time values.

1. // pseudocode
   
2. if (collide) {
3.   time++;
4.   globaltime++;
5. }

2. Go over all the objects and add up their times when you need to know the totalTime.

1. // pseudocode
2. int totalTime() {
3.   int totalTime = 0;
4.   for (Object b : myObjects) {
5.     totalTime += b.time;
6.   }
7.   return totalTime;
8. }

cool thanks!, i ve made this program but its not working as expected,
The idea of the program is that it has agents and obstacles. Everytime i create execute the program it organizes the obstacles in a random way. So im trying to evaluate which diposition of the obstacles can optimize the flow of agents.
In this way my criteria  for selecting a bad organization of obstacles or good organization of obstacles is the global time that the agents collide with the obstacles.
it seems the globalvariable is working fine but the colors of the agents doesnt change when they collider.
Any idea?

1. 
   int globaltime;
   
   Tienda[] arreglo =new  Tienda[60];
   Agente[] arreglo_dos =new  Agente[60];
   
   void setup(){
     size(400,400);
     for (int i=0; i<60; i++){
       arreglo[i] = new Tienda();  
       arreglo_dos[i]  = new Agente(); 
     }
   }
   
   
   void draw(){
     background(220, 13, 133);
     for (int i=0; i<60; i++){
       arreglo[i].dibuja();
       arreglo_dos[i].dibuja();
   
     }
   }
   
   
   
   class Tienda{
    float x= random(400);
    float y= random(400);
     
      void dibuja(){
         fill(120, 24, 220);
         ellipse(x,y,30,30);
        }
    
    }
   
   
   
   class Agente{
    float x= random(400);
    float y= random(400);
    color coloro = color(250, 44, 0);
      float dista;
     
      int time = 0;
     
      void dibuja(){
        println(globaltime);
        fill(coloro);
        ellipse(x,y,5,5);
        x = x + 0.8;
        y = y - 0.5;
       
        for (int i=0; i<60; i++){
          int collisionCount = 0;
          if ( arreglo_dos[i] !=  this){
            dista = dist( x, y , arreglo[i].x , arreglo[i].y );
   
             if (dista < 30){
              
               time++;
               globaltime++;
               coloro = color(222, 40, 0);
            
               // collisionCount++;
             }
             else
             {
   
               coloro =  color(262, 240, 230);
             }
          
         }
      
       }
     }
    
    
   }
   

General advice: don't use "magic" numbers like 400, 60, 30 in your code. Use constants defined at the global level (30) or existing (width, height -> the sketch's dimension, arreglo_dos.length -> the number of agents, arreglo.length -> the number of obstacles, etc.). This allows to change the numbers easily, without having to remember if 60 at a given place is the number of agents or obstacles, and it might avoid confusions. That, and more distinct names... (if they don't confuse you, it might confuse other readers, particularly if they don't read Spanish...).

For collision, you check if an agent can collide with itself, which is a good idea, except that currently you only check for collision against obstacles... Not a real problem, just strange in the current context.
Also, you check the collision against all obstacles, and set the color each time, on each iteration. So only the last test, against the last obstacle of the list, wins...
You should set the non-collision color before the loop, assign only if there is a collision, and add break after the color change, as there is little change the agent will collide against two obstacles (even if it is possible, since they overlap, it isn't important in your case). This might even speed up a bit the code.