<script type="text/javascript"> 
 <!--
 
 //Código ajax do mentawai responsável por efetuar o logout antes de fechar o browser. 
 //Para maiores esclarecimentos sobre esta função leia: FAQ: Ajax Fácil com Mentawai (MentaAjax)
 function doRequest() {
 var req = new mtw.request();
 req.setUrl("/MinhaApp/Logout.do");
 req.onSuccess(true);
 req.send();
  }
 
 // Iniciamos setando uma variável que será responsável em dizer se a página está sendo
 // recarregada ou não. Note que a variável inicia com valor false. Isto é muito importante.
 var reloaded = false;
 // Esta função verifica se está sendo dado algum comando através do teclado para
 // recarregar a página (F5, CTRL + R). Ela retorna true ou false
 function checkReload(evt) {
 	if(evt.keyCode == 116 || (evt.altKey && evt.keyCode == 82))
 	return true;
 	else
 	return false;
 }
 // Aqui nós verificamos quais as teclas o usuário está pressionando.
 // Neste momento só nos interessa saber duas coisas: se o usuário está fechando o browser ou se
 // ele está apenas recarregando. No nosso caso nós só queremos executar algo se o usuário sair
 // indevidamente do sistema, então se ele recarregar a página nada deverá ser executado.
 // Este é o ponto crucial do script.
 // Se o usuário estiver tentando fechar o navegador (ALT + F4 ou CTRL + F4) a variável reloaded 
 //será setada como false, ou seja, o usuário não está recarregando a página. Portanto nós podemos
 // executar nossa função de LOGOUT. Agora se o usuário está tentando recarregar a página (F5,
 // CTRL + R...) a variável será setada como true e nada irá acontecer.
 function verify(evt) {
 	// CTRL + F4
 	if(evt.ctrlKey && evt.keyCode == 115) {
 		reloaded = false;
 	}
 	// ALT + F4
 	if(evt.altKey && evt.keyCode == 115) {
 		return reloaded = false;
 	}
 	// F5 e CTRL + R
 	if(checkReload(evt)) {
 		return reloaded = true;
 	}
 }
 // Esta função faz o trabalho crucial. Ela recebe uma variável: a browserFlag que indica qual
 // navegador está sendo utilizado. Esta variável foi mantida apenas no caso de você querer fazer
 // algo diferente para cada navegador. No caso nós chamamos a mesma função para todos os
 // navegadores, então não seria necessária esta verificação. Mas fica aí como exemplo :)
 // Ao chamar a função, esta mesma verifica qual o valor da variável global reloaded. Se esta for
 // false (o navegador não está sendo recarregado) ela envia uma requisição ao servidor através
 // de uma função ajax solicitando que a sessão seja derrubada. Se for true, nenhuma requisição
 // é enviada e nada acontece. Lembrando que neste ponto você pode fazer oque quiser, basta
 // mudar o código da função para incrementá-la.
 function closeWindow(browserFlag) {
 	if(!reloaded) {
 		if(browserFlag == 'ie') {
 			doRequest();
 		} else { 
 			doRequest();
 		}
 	}
 }
 // Aqui é realmente a parte mais importante do código, pode-se dizer. Verificamos com um simples 
 // "if" qual o browser está sendo utilizado. if(!document.addEventListener &&
 //document.attachEvent) quer dizer se não existir o método addEventListener e existir o método
 // attachEvent então estamos trabalhando com o IE ou algum browser que suporte este método
 // e utilizaremos o attachEvent. Caso contrário, o browser não suporta o attachEvent mas
 // suporta o addEventListener, então o utilizaremos.
 // Lembrando que todos os browsers modernos e atuais suportarão ou um ou outro.
 if(!document.addEventListener && document.attachEvent) {
 	// Aqui nós fazemos com que o evento keydown (que é disparado sempre que uma tecla for
 // pressionada) seja ouvido pelo objeto document da árvore DOM. Então sempre que o
 // usuário apertar algum botão na tela a função verify será chamada e será verificado
 // o que ele está fazendo.
 	document.attachEvent("onkeydown", function(){verify(event)});
 	// Esta é realmente a chave do código. A função closeWindow é chamada apenas aqui.
 	// Nós adicionamos o evento beforeunload no objeto window. Sempre que este evento
 	// for disparado a função closeWindow será chamada e fará as verificações necessárias.
 	// Isto ocorrerá sempre antes de a página mudar, for recarregada, for fechada... seja
 // através de algum botão do navegador, ou algum comando do teclado. Ou seja, seja lá
 // o que for acontecer na janela esta função será chamada :)
 	window.attachEvent("onbeforeunload", function(){closeWindow('ie')});
 
 } else {
 	// No FF em específico quando o evento beforeunload é disparado se a página não estiver
 // totalmente carregada ele atropela tudo e dispara a função encerrando a função.
 // Como alternativa, nós deixamos a variável setada inicialmente como true, oque
 // não deixará a funão closeWindow enviar a requisição ao servidor. Essa variável
 // somente irá passar para false quando a página for carregada, e quando o usuário mover 
 // o mouse sobre a tela. Este é um contorno para um pequeno bug.
 	reloaded = true;
 	// Mesma coisa do IE
 	document.addEventListener('keydown',function(event){verify(event);},false);
 	window.addEventListener('beforeunload',function(event){closeWindow('ff');},false);
 	// Ao mover o mouse a variável reloaded receberá o valor padrão correto, false
 	document.addEventListener('mousemove',function(){reloaded=false;},false);
 }
 
 
 //-->
 </script>

public class LoginAction extends BaseLoginAction implements HttpSessionAttributeListener {
 
 private static final String MAX_LOGIN_ERROR = "Desculpe o número máximo de usuários logados foi atingido :-(";
 
 public String execute() throws Exception {
     	Usuario user = model.isOk();
 
         if (user != null) {
 
 //Imprimindo os valores
         	System.out.println("Quantidade de usuários logados = "+application.getAttribute("quantidade_de_logados"));
         	System.out.println("Quantidade máxima de usuários = "+application.getAttribute("maximo_de_logados"));
 
 /*
 * Vamos validar a quantidade de usuários logados. Se a quantidade de
 * logados for inferior ao máximo permitido retorna success e dispara o 
 * usuário para a tela do sistema
 */
         	if ((Integer)application.getAttribute("quantidade_de_logados ") < (Integer) application.getAttribute("maximo_de_logados")) {
 	        	setUserSession(user);
 	        	return SUCCESS;
 /*
 * Caso o número limite de usuários logados foi atingido o usuário será 
 * reencaminhado a tela de login com uma mensagem de erro, informando que
 * o limite de usuários foi atingido. 
 */
         	}else{
         		addError(MAX_LOGIN_ERROR);
                 return ERROR;
         	}
         }
         addError(LOGIN_ERROR);
         return ERROR;
     }
 
 public void attributeAdded(HttpSessionBindingEvent e) {
 		ServletContext c = e.getSession().getServletContext();
 		synchronized (c) {
 //Verificamos se o objeto inserido no session é uma instancia do nosso 
 //bean Usuario
 			if (e.getValue() instanceof Usuario && e.getName().equalsIgnoreCase("user")) {
 				Integer logUsers = (Integer) c.getAttribute("quantidade_de_logados");
 //Contador
 				logUsers++;
 				c.setAttribute("quantidade_de_logados", logUsers);
 				System.out.println("Novo usuário logado");
 			}
 		}
 	}
 
 	public void attributeRemoved(HttpSessionBindingEvent e) {
 		ServletContext c = e.getSession().getServletContext();
 		synchronized (c) {
 //Verificamos se o objeto inserido no session é uma instancia do nosso 
 //bean Usuario
 			if (e.getValue() instanceof Usuario && e.getName().equalsIgnoreCase("user")) {
 
 				Usuario u = (Usuario) e.getValue();
 				System.out.println("O usuário "+u.getNome()+" deslogou corretamente!");
 
 				Integer logUsers = (Integer) c.getAttribute("quantidade_de_logados");
 				logUsers--;
 				c.setAttribute("quantidade_de_logados", logUsers);
 			}
 		}
 	}
 
 	public void attributeReplaced(HttpSessionBindingEvent e) {}
 
 
 
 }

<listener>
 	<listener-class>
 	meuspacotes.LoginAction
 	</listener-class>
 </listener>

 public class ApplicationManager extends org.mentawai.core.ApplicationManager {
 
   private Integer maximo_de_logados  = 0;
 
   public void init(Context application) {
 	//Setando o valor máximo de usuários logados ? default 0, ao se rodar o aplicação o valor começará a partir do zero.
    	application.setAttribute("maximo_de_logados", maximo_de_logados);
   }
 
 }

 if(!document.addEventListener && document.attachEvent) {
     document.attachEvent("onkeydown",function(){verify(event)});
     window.attachEvent("onbeforeunload",function(){closeWindow('ie')});
 } else {
     reloaded = true;
     document.addEventListener('keydown',function(event){verify(event);},false);
     window.addEventListener('beforeunload',function(event){closeWindow('ff');},false);
     document.addEventListener('mousemove',function(){reloaded=false;},false);
 }
 

	
 if(document.addEventListener) {
     reloaded = true;
     Event.observe(document, 'mousemove', function(){reloaded=false;}, false);		
 }
     Event.observe(document, 'keydown', verify, false);
     Event.observe(window, 'beforeunload', closeWindow, false);	
 

 <%@ taglib uri="/WEB-INF/lib/mentawai.jar" prefix="mtw"%>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
     <title>Teste logoff </title>
 <mtw:ajaxConfig />
 <script>
 var reloaded = false;
 function verify(event) {
 	// CTRL + F4 ou ALT + F4
 	if((event.ctrlKey || event.altKey) && event.keyCode == 115) return reloaded = false;
 
 	// F5 e CTRL + R
 	if(event.keyCode == 116 || (event.altKey && event.keyCode == 82)) return reloaded = true;
 }
 
 function closeWindow() {
 	if(!reloaded) {
 	 	var req = new mtw.request();
 	 	req.setUrl("<mtw:contextPath/>/Logout.do");
 	 	req.onSuccess(true);
 	 	req.send();
 	}
 	
 }
 //
 // Event listeners
 //
 if(document.addEventListener) {
 	reloaded = true;
 	Event.observe(document, 'mousemove', function(){reloaded=false;}, false);		
 }
 Event.observe(document, 'keydown', verify, false);
 Event.observe(window, 'beforeunload', closeWindow, false);	
 </script>
 </head>
 <body>
 Clique para fechar o browser, ou ALT+F4, CTRL+F4, se vc estiver utilizando o LISTENER 
 repare que será informado que o usuário X efetuou o logoff corretamente.
 </body>
 </html>
 

 // F5 , CTRL + R e CTRL + F5
  	if(event.keyCode == 116 || 
                   (event.ctrlKey && (event.keyCode == 82 || event.keyCode == 116))) return reloaded = true;
 

 			var reloaded = false;
 			 function verify(event) {
 			 
 			 	alert("event.ctrlKey " + event.ctrlKey);
 			 	alert("event.altKey " + event.altKey);
 			 	alert("event.keyCode " + event.keyCode);
 			 
 			 	// CTRL + F4 ou ALT + F4		 	
 			 	if((event.ctrlKey || event.altKey) && event.keyCode == 115){
 			 		reloaded = false;
 			 		alert(reloaded);
 			 		return reloaded;
 			 	}
 			 
 				// F5 e CTRL + R
 				if(event.keyCode == 116 || (event.ctrlKey && event.keyCode == 82)){
 					reloaded = true;
 					alert(reloaded);
 					return reloaded; 
 				}
 			 }
 			 
 			 function closeWindow() {
 			 	if(!reloaded) {
 			 		alert("Close " + reloaded);
 			 	 	var req = new mtw.request();
 			 	 	req.setUrl("<mtw:contextPath/>/Logout.mtw");
 			 	 	req.onSuccess(true);
 			 	 	req.send();
 			 	}
 			 }
 			 
 			 //
 			 // Event listeners
 			 //
 			 if(document.addEventListener) {
 			 	alert("document.addEventListener");
 			 	reloaded = true;
 			 	Event.observe(document, 'mousemove', function(){reloaded=false;}, false);		
 			 }
 			 
 			 Event.observe(document, 'keydown', verify, false);
 			 Event.observe(window, 'beforeunload', closeWindow, false);