<listener>
     	<listener-class>
 br.com.linkzsistemas.espacolazer.agendamento.AgendadorTarefaServetListener
     	</listener-class>
 
     </listener>

public class AgendadorTarefaServetListener implements ServletContextListener {	
 	private static Logger logger = LoggerFactory.getLogger(AgendadorTarefaServetListener.class);
 	private static boolean debug = logger.isDebugEnabled();	
 
 	private AgendadorTarefaThread thread;
 
 	@Override
 	public void contextInitialized(ServletContextEvent event) {
 		logger.info("-------- contextInitialized -------- ");
 		thread = new AgendadorTarefaThread();
 		thread.start();
 	}
 	
 	@Override
 	public void contextDestroyed(ServletContextEvent event) {
 		logger.info("-------- contextDestroyed -------- ");
 		thread.shutdownScheduler();
 	}
 
 
 
 }

 /**
  * Thread usada para iniciar o Agendamento de Tarefas, ele deve ser startado
  * quando o Contexto da Aplicação for Inicializado.
  * 
  *	
  * @author Ricardo JL Rufino (ricardo@linkzsistemas.com.br)
  * @date 19:04:30 25/04/2009
  * @update 
  * @since 1.0
  */
 public class AgendadorTarefaThread extends Thread{
 	private static Logger logger = LoggerFactory.getLogger(AgendadorTarefaThread.class);
 	private static boolean debug = logger.isDebugEnabled();
 	
 	private static Scheduler scheduler;
 	
 	/** Tempo em que a thread fica em espera para mostrar as estatísticas */
 	private long sleepTime;
 	
 	
 	@Override
 	public void run() {
 		try {
 	        logger.info("-------------- Incializando ------------------- (ThreadID = " + this.getId() + ")");
 
 	        // Inicializar o Agendador (Scheduler)
 	        SchedulerFactory sf = new StdSchedulerFactory();
 	        scheduler = sf.getScheduler();
 
 
 	        logger.info("------- Agendando Jobs ----------------");
 
 	        Trigger triggerDiaria = TriggerUtils.makeDailyTrigger(12, 0);
 	        triggerDiaria.setName("triggerDiariaAs12h-1");
 	        
 	        Trigger triggerDiaria2 = TriggerUtils.makeDailyTrigger(12, 0);
 	        triggerDiaria2.setName("triggerDiariaAs12h-2");	    
 
 	        
 	        JobDetail jobCancelamento = new JobDetail("CancelamentoAutomaticoJob", Scheduler.DEFAULT_GROUP, CancelamentoAutomaticoJob.class);
 	        JobDetail jobBaixaAutomatica = new JobDetail("BoletoBaixaAutomaticaJob", Scheduler.DEFAULT_GROUP , BoletoBaixaAutomaticaJob.class);
 	        
 	        // Agentar tarefa.
 	        scheduler.scheduleJob(jobCancelamento, triggerDiaria);
 	        scheduler.scheduleJob(jobBaixaAutomatica, triggerDiaria2);
 	        
 
 	        logger.info("------- Starting Scheduler ----------------");
 
 	        // All of the jobs have been added to the scheduler, but none of the jobs
 	        // will run until the scheduler has been started
 	        scheduler.start();
 
 	        logger.info("------- Started Scheduler -----------------");
 	        
 	        while(scheduler.isStarted()){
 		        try {
 		        	logger.info("------- Colocando a Thred em Estado de Espera --------- (ThreadID = " + this.getId() + ")");
 		        	
 		        	SchedulerMetaData metaData = scheduler.getMetaData();
 		        	 
 		        	logger.info("------- Estatisticas --------- ");
 			        logger.info("{} tarafas executadas desde: {}",metaData.numJobsExecuted(), DateUtils.formatDateTime(metaData.runningSince()));
 			        
 			        String[] triggers = scheduler.getTriggerNames(Scheduler.DEFAULT_GROUP);
 			        for (String triggerName : triggers) {
 			        	Trigger trigger = scheduler.getTrigger(triggerName, Scheduler.DEFAULT_GROUP);
 			        	logger.info(trigger.getName() + ": prox. execução: {}", DateUtils.formatDateTime(trigger.getNextFireTime()));
 					}
 
 		        	Thread.sleep(sleepTime); 
 		        } catch (Exception e) {
 		        	e.printStackTrace();
 		        }	        	
 	        }
 	      	
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 	}
 	
 	
 	/**
 	 * Finalizar o Agendador de Tarefas
 	 * @author Ricardo
 	 * @since 1.0
 	 */
 	public void shutdownScheduler() {
 		try {
 			scheduler.shutdown();
 		} catch (SchedulerException e) {
 			e.printStackTrace();
 		}
 	}
 
 
 
 	public static void main(String[] args) {
 		new AgendadorTarefaThread().start();
 	}
 
 }
 

 public class EnviadorServletListener implements ServletContextListener {
 
     private EnviadorThread thread;
 
     public void contextInitialized(ServletContextEvent sce) {
         thread = new EnviadorThread();
         thread.start();
     }
 
     public void contextDestroyed(ServletContextEvent sce) {
         thread.shutdownScheduler();
     }
 
 }
 

 public class EnviadorThread extends Thread {
 
     private static Scheduler scheduler;
 
     @Override
     public void run() {
         try {
 
             scheduler = StdSchedulerFactory.getDefaultScheduler();
 
             Trigger triggerEnviador = TriggerUtils.makeMinutelyTrigger(2);
 
             triggerEnviador.setName("TriggerEnviador");
             triggerEnviador.setStartTime(new Date());
 
             JobDetail jobEnviador = new JobDetail("jobEnviador", null, JobEnviador.class);
 
             scheduler.scheduleJob(jobEnviador, triggerEnviador);
 
             scheduler.start();
 
         } catch (SchedulerException ex) {
             ex.printStackTrace();
         }
     }
 
     public void shutdownScheduler() {
         try {
             scheduler.shutdown();
         } catch (SchedulerException e) {
             e.printStackTrace();
         }
     }
 
     public static void main(String[] args) {
         new EnviadorThread().start();
     }
 }
 

 public class JobEnviador implements Job {
 
     private Session session;
     private Transaction txn;
 
     public JobEnviador() {  }
 
     public void execute(JobExecutionContext arg0) throws JobExecutionException {
         
         session = HibernateUtil.getSession();
         //sua logica
         session.close();
     }
 }
 

 <listener>
     <listener-class>EnviadorServletListener</listener-class>
 </listener>