Java PriorityBlockingQueue.size方法代码示例

import java.util.concurrent.PriorityBlockingQueue; //导入方法依赖的package包/类
public double calculaCosteAtencionVictimasFinalesAsignadas(double factorMultiplicativo, VictimsToRescue victims2R, MisObjetivos misObjs){

		double tiempo = 0;     //Variable para calcular el tiempo

    	PriorityBlockingQueue <Objetivo> colaobjetivos = misObjs.getMisObjetivosPriorizados();
    	int tamaniocola = colaobjetivos.size();

    	Iterator<Objetivo> it = colaobjetivos.iterator();

        if (tamaniocola==0){
        	return 0;
        }

    	while (it.hasNext()){
  		  //Hay al menos un objetivo
  	      Objetivo ob = it.next();
  	      String referenciaIdObjetivo = ob.getobjectReferenceId();

	      //Obtener la victima de la cola
	      Victim victimaActualCola = victims2R.getVictimToRescue(referenciaIdObjetivo);    	          	      
	      int prioridadVictimaActualCola = victimaActualCola.getPriority();
	      
	      tiempo = tiempo + (factorMultiplicativo*prioridadVictimaActualCola);
    	}    	    	    	
    	return tiempo;
	}
 

import java.util.concurrent.PriorityBlockingQueue; //导入方法依赖的package包/类
/**
 * Store sensor data so that it can be published in the next publishing cycle. Unlike
 * the other log methods, this method saves the {@link #BUFFER_SIZE_FOR_ONCHANGE_SENSORS} most
 * recent sensor readings per sensor type.
 * @param data
 */
public void logSensorDataOnChange(SensorData data) {
    PriorityBlockingQueue<SensorData> newQueue =
            new PriorityBlockingQueue<SensorData>(BUFFER_SIZE_FOR_ONCHANGE_SENSORS,
                    new Comparator<SensorData>() {
        @Override
        public int compare(SensorData o1, SensorData o2) {
            return Long.compare(o1.getTimestamp(), o2.getTimestamp());
        }
    });
    PriorityBlockingQueue<SensorData> lastData = mOnChangeData.putIfAbsent(
            data.getSensorName(), newQueue);

    if (lastData == null) {
        lastData = newQueue;
    }

    // remove old entries if necessary
    while (lastData.size() >= BUFFER_SIZE_FOR_ONCHANGE_SENSORS) {
       lastData.poll();
    }

    lastData.offer(data);
}
 

import java.util.concurrent.PriorityBlockingQueue; //导入方法依赖的package包/类
private ArrayList getIdsVictimasFinalesAsignadas(MisObjetivos misObjs, VictimsToRescue victims2R){
	ArrayList aux = new ArrayList();

	PriorityBlockingQueue <Objetivo> colaobjetivos = misObjs.getMisObjetivosPriorizados();
	int tamaniocola = colaobjetivos.size();

	Iterator<Objetivo> it = colaobjetivos.iterator();

    if (tamaniocola==0){
    	return aux;
    }
    
	int index = 0;
	while (it.hasNext()){    		
		  //Hay al menos un objetivo
	      Objetivo ob = it.next();
	      String referenciaIdObjetivo = ob.getobjectReferenceId();

         //Obtener la victima de la cola
         Victim victimaActualCola = victims2R.getVictimToRescue(referenciaIdObjetivo);  	          
         String nameVictim = victimaActualCola.getName();
       
         aux.add(index, nameVictim);
         index ++;  	        
	}
	
	return aux;
}
 

import java.util.concurrent.PriorityBlockingQueue; //导入方法依赖的package包/类
@Override
public void enqueueLog(Path log) {
  String logPrefix = DefaultWALProvider.getWALPrefixFromWALName(log.getName());
  PriorityBlockingQueue<Path> queue = queues.get(logPrefix);
  if (queue == null) {
    queue = new PriorityBlockingQueue<Path>(queueSizePerGroup, new LogsComparator());
    queues.put(logPrefix, queue);
    if (this.sourceRunning) {
      // new wal group observed after source startup, start a new worker thread to track it
      // notice: it's possible that log enqueued when this.running is set but worker thread
      // still not launched, so it's necessary to check workerThreads before start the worker
      final ReplicationSourceWorkerThread worker =
          new ReplicationSourceWorkerThread(logPrefix, queue, replicationQueueInfo, this);
      ReplicationSourceWorkerThread extant = workerThreads.putIfAbsent(logPrefix, worker);
      if (extant != null) {
        LOG.debug("Someone has beat us to start a worker thread for wal group " + logPrefix);
      } else {
        LOG.debug("Starting up worker for wal group " + logPrefix);
        worker.startup();
      }
    }
  }
  queue.put(log);
  int queueSize = logQueueSize.incrementAndGet();
  this.metrics.setSizeOfLogQueue(queueSize);
  // This will log a warning for each new log that gets created above the warn threshold
  if (queue.size() > this.logQueueWarnThreshold) {
    LOG.warn("WAL group " + logPrefix + " queue size: " + queueSize
        + " exceeds value of replication.source.log.queue.warn: " + logQueueWarnThreshold);
  }
}
 

import java.util.concurrent.PriorityBlockingQueue; //导入方法依赖的package包/类
public double CalculaDistanciaCamino(String nombreAgenteEmisor, Coordinate posicionActualRobot, Victim nuevaVictima, VictimsToRescue victims2R, MisObjetivos misObjs){

        boolean flag = true;
        double distancia = 0;     //Variable para calcular la distancia para recorrer el camino de las victimas actualmente asignadas, incluyendo la nueva victima actual que ha llegado 

        Coordinate coordinateNuevaVictima = nuevaVictima.getCoordinateVictim();         
        int prioridadNuevaVictima = nuevaVictima.getPriority();
         Objetivo ob;
    	PriorityBlockingQueue <Objetivo> colaobjetivos = misObjs.getMisObjetivosPriorizados();
    	int tamaniocola = colaobjetivos.size();
    	
        Victim victimaAnteriorCola = null;
    	Coordinate coordinateVictimaAnteriorCola = null;
    // Hacer un analisis de casos 
    // Caso 1 Hay un objetivo en la cola de objetivos pero no tiene que ver con hacerse cargo de la victima
    //        victims2R contine la nueva victima que sera la ultima almacenada
    //        El coste debe consistir en el calculo a partir de la distancia      
//        if (tamaniocola == 0 ) return  distanciaC1toC2(posicionActualRobot, coordinateNuevaVictima);
//        else if (tamaniocola == 1){
//         String refVictim = misObjs.getobjetivoMasPrioritario().getobjectReferenceId();
//            if(refVictim == null||(victims2R.getvictims2Rescue().isEmpty() ||
//                                   victims2R.getVictimToRescue(refVictim) == null )
//               ) return distanciaC1toC2(posicionActualRobot, coordinateNuevaVictima);  
//        }
        distancia= distanciaC1toC2(posicionActualRobot, coordinateNuevaVictima);
        if (tamaniocola >1 ) {
            
    	Iterator<Objetivo> it = colaobjetivos.iterator();
                        
        //Mostrar informacion del calculo de la evaluacion en ventana de trazas Evaluacion
    	//trazas.aceptaNuevaTraza(new InfoTraza("Evaluacion", "CALCULANDO DISTANCIA .......... Agente " + nombreAgenteEmisor, InfoTraza.NivelTraza.info)); 
    	int i = 1;
    	while (it.hasNext()){
    		  //Hay al menos un objetivo
    	    ob = it.next();
            if ( ob.getState()!= Objetivo.SOLVED){
    	      String referenciaIdObjetivo = ob.getobjectReferenceId();
    	      //Obtener la victima de la cola
                Victim victimaActualCola = victims2R.getVictimToRescue(referenciaIdObjetivo);    	          	      
                int prioridadVictimaActualCola = victimaActualCola.getPriority();    	          	          	      
                Coordinate coordinateVictimaActualCola = victimaActualCola.getCoordinateVictim();   	          	      
                if (flag == false){
    	    	  //terminar el recorrido por el resto de victimas de la cola
    	    	  distancia = distancia + distanciaC1toC2(coordinateVictimaAnteriorCola, coordinateVictimaActualCola);
                }
                else{     	      
                    if (prioridadVictimaActualCola >= prioridadNuevaVictima){
    	    		  	if (i==1){
    	    	    	   //distancia del robot a la nueva victima
    	    		  		distancia = distanciaC1toC2(posicionActualRobot, coordinateVictimaActualCola);
    	    		  	}
    	    		  	else{
    	    		  		distancia = distancia + distanciaC1toC2(coordinateVictimaAnteriorCola, coordinateVictimaActualCola); 
    	    		  	}
    	    		  	if (i==tamaniocola) 
    	    		  		distancia = distancia + distanciaC1toC2(coordinateVictimaActualCola, coordinateNuevaVictima);
                    }else{ //prioridadVictimaActualCola < prioridadNuevaVictima
     	    		    if (i==1){
    	    			      distancia = distanciaC1toC2(posicionActualRobot, coordinateNuevaVictima);
    	    		    }
    	    		    else {
    	    			  distancia = distancia + distanciaC1toC2(coordinateVictimaAnteriorCola, coordinateNuevaVictima);
    	    		    }
                            distancia = distancia + distanciaC1toC2(coordinateNuevaVictima, coordinateVictimaActualCola);
                            flag = false;
                        }
                    }
                    i = i + 1;
                    victimaAnteriorCola = victimaActualCola;
                    coordinateVictimaAnteriorCola = victimaAnteriorCola.getCoordinateVictim();
            }
    	} //fin del while
        }
    	//trazas.aceptaNuevaTraza(new InfoTraza("Evaluacion", 
    	//		"CalculaDistancia: Agente " + nombreAgenteEmisor + ": Distancia->" + distancia 
    	//		, InfoTraza.NivelTraza.info));       		        		                                                           		        		          		           
    	
    	return distancia;
    }
 

import java.util.concurrent.PriorityBlockingQueue; //导入方法依赖的package包/类
public double calculaCosteRecorrerCaminoVictimas(String nombreAgenteEmisor, Coordinate posicionActualRobot, VictimsToRescue victims2R, MisObjetivos misObjs){    	
    double tiempoCamino = 0;     //Variable para calcular el tiempo para recorrer el camino de las victimas asignadas        
    double tiempoAux = 0;
    
	PriorityBlockingQueue <Objetivo> colaobjetivos = misObjs.getMisObjetivosPriorizados();
	int tamaniocola = colaobjetivos.size();

	Iterator<Objetivo> it = colaobjetivos.iterator();

    if (tamaniocola==0){
    	return 0;
    }
                    
	int i = 1;
	Coordinate coordinateaux = new Coordinate(0.0,0.0,0.0);
	coordinateaux = posicionActualRobot;
	    	
	while (it.hasNext()){
 	  //Hay al menos un objetivo    		
     Objetivo ob = it.next();
     String referenciaIdObjetivo = ob.getobjectReferenceId();

   //Obtener la victima de la cola
   Victim victimaActualCola = victims2R.getVictimToRescue(referenciaIdObjetivo);
   Coordinate coordinateVictimaActualCola = victimaActualCola.getCoordinateVictim();
   if (i==1){
 	  		//distancia del robot a la nueva victima
 	  		tiempoAux = tiempoAux + distanciaC1toC2(coordinateaux, coordinateVictimaActualCola);
 	  		coordinateaux = coordinateVictimaActualCola;
 	  		i=2;
   }
   else{
 		        //distancia de una victima a la siguiente victima a visitar
 		        tiempoAux = tiempoAux + distanciaC1toC2(coordinateaux, coordinateVictimaActualCola);
 		        coordinateaux = coordinateVictimaActualCola;
 		        i++;
   }	      	      
	}        
	System.out.println("Numero de victimas asignadas al robot " + nombreAgenteEmisor + " -> " + (i-1));    	
	tiempoCamino = tiempoAux;    	
	return tiempoCamino;    	
}