Java Cancellable.cancel方法代码示例

import akka.actor.Cancellable; //导入方法依赖的package包/类
private void scheduleWeeklyReport() {
    FiniteDuration delay = FiniteDuration.create(secondsUntilNextMondayRun(), TimeUnit.SECONDS);
    Cancellable reportTask = tasks.remove("REPORT_SENDER");
    if (reportTask != null) {
        reportTask.cancel();
    }
    tasks.put("REPORT_SENDER", system.scheduler().scheduleOnce(delay, () -> {
        Logger.info("Running weekly email report");
        List<User> teachers = Ebean.find(User.class)
                .fetch("language")
                .where()
                .eq("roles.name", "TEACHER")
                .findList();
        teachers.forEach(t -> {
            try {
                composer.composeWeeklySummary(t);
            } catch (RuntimeException e) {
                Logger.error("Failed to send email for {}", t.getEmail());
            }
        });
        // Reschedule
        scheduleWeeklyReport();
    }, system.dispatcher()));
}
 

import akka.actor.Cancellable; //导入方法依赖的package包/类
private void onSelectOwner(final SelectOwner selectOwner) {
    LOG.debug("{}: onSelectOwner: {}", persistenceId(), selectOwner);

    String currentOwner = getCurrentOwner(selectOwner.getEntityPath());
    if (Strings.isNullOrEmpty(currentOwner)) {
        writeNewOwner(selectOwner.getEntityPath(), newOwner(currentOwner, selectOwner.getAllCandidates(),
                selectOwner.getOwnerSelectionStrategy()));

        Cancellable cancellable = entityToScheduledOwnershipTask.get(selectOwner.getEntityPath());
        if (cancellable != null) {
            if (!cancellable.isCancelled()) {
                cancellable.cancel();
            }
            entityToScheduledOwnershipTask.remove(selectOwner.getEntityPath());
        }
    }
}
 

import akka.actor.Cancellable; //导入方法依赖的package包/类
void terminated(ActorRef child) {
    Cancellable scheduledTermination = scheduledTerminations.get(child);
    if (scheduledTermination != null) {
        // The child terminated in time, so we should cancel the scheduled termination.
        scheduledTermination.cancel();
    }
}
 

import akka.actor.Cancellable; //导入方法依赖的package包/类
public void cancel() {
    log.info("***** START cancel JobsServiceImpl ****");
    for (Cancellable scheduler : schedulers) {
        if (scheduler != null) {
            scheduler.cancel();
            log.info("***** Scheduler was not null and is cancelled ****");
        }
    }
    log.info("***** END cancel JobsServiceImpl ****");
}
 

import akka.actor.Cancellable; //导入方法依赖的package包/类
private void cancelOwnerSelectionTask(final YangInstanceIdentifier entityPath) {
    final Cancellable lastScheduledTask = entityToScheduledOwnershipTask.get(entityPath);
    if (lastScheduledTask != null && !lastScheduledTask.isCancelled()) {
        lastScheduledTask.cancel();
    }
}
 

import akka.actor.Cancellable; //导入方法依赖的package包/类
/** Run the Monitor. */
    public final void run() {
    	    	  	
		systemMonitor = ActorSystem.create("MonitorSystem"); 
		//creation de l'actor Action
		action = systemMonitor.actorOf(new Props(new UntypedActorFactory() {
			public UntypedActor create() {
			 return new Action(controllerSoftwareService,controllerVmService,controllerKubectlService,nameReplicationController);
			}
		}), "Actionneur");	
		//creation de l'actor Decide
		decide = systemMonitor.actorOf(new Props(new UntypedActorFactory() {
			public UntypedActor create() {
			 return new Decide(action,sh,eventNotificationAlertService);
			}
		}), "Decideur");	
		//creation l'actor Analyse
		analyse = systemMonitor.actorOf(new Props(new UntypedActorFactory() {
			public UntypedActor create() {
			 return new Analyse(decide,sh,eventNotificationAlertService);
			}
		}), "Analyseur");
		
		//creation de l'actor Collect des traces de la version Japonais de Wikipedia
//		collect = systemMonitor.actorOf(new Props(new UntypedActorFactory() {
//			public UntypedActor create() {
//			 return new CollectTraceWikipedia(analyse,sh);
//			}
//		}), "Collect");

		//creation de l'actor Collect en temps réel
		collect = systemMonitor.actorOf(new Props(new UntypedActorFactory() {
			public UntypedActor create() {
			 return new CollectRealTime(analyse,sh);
			}
		}), "Collect");
		
		
		  System.out.println("START");
		  //lecture du nombre de requettes tous les 30 secondes
		  Cancellable cancellable = systemMonitor.scheduler().schedule(Duration.Zero(),Duration.create(30, "seconds"),collect, new Interval(30));				  
		  try {
			  Thread.sleep(30000000);
			} catch (InterruptedException e) {
				System.out.println(e.getStackTrace());
				return;
			}
		 
		  cancellable.cancel();
		  System.out.println("END");   	
    }