Mensagens enviadas por: danieldestro

Do meu iPhone:

g4j wrote:e esse?

public void showMsg(String msg){ System.out.println(msg); }

acreditem, encontrei em uma classe de "utilidades"

"ABSTRAÇÃO"

Até poderia criar um método "cancel" na minha thread e ela chamar o "close" ou algo do tipo do Stream. É uma ideia sim. Posso testar.

Pois é Viny. Me alertei ao fato de "stop" e "destroy" serem deprecated, porém era a última tentativa de tentar abortar threads do meu processo.

O fato é que estas threads executam tarefas que eu não tenho controle sobre a execução, ou seja, não posso executar aos poucos e abortar sua execução.

Porém, acreditei que eu poderia simplesmente abortar a execução geral de uma thread "por fora", mas vejo que não dá mesmo.

Conhece alguma solução para o caso?

Acabei também achando um "bug" na aplicação e coloquei um timeout em um serviço HTTP que tava dando problema. Acho que resolvi pontualmente o problema aqui, porém, nada impede que outros "timeouts" possam ocorrer e meu sistema entra em "hang".

Coloquei "stop" no lugar de "interrupt" na linha 112 e funcionou neste teste ai. Porém, no sistema real não rolou não. Ele não para a thread.

Caros,

Tenho um sistema que precisa executar múltiplas tarefas em parelelo e para isso usei o conceito de pool de threads.

A principio desenvolvi uma solução para atender meus requisitos. Porém estou apanhando para fazer com que cada tarefa execute dentro de um período de timeout ou então seja interrompida.

Segue uma a implementação (obviamente simplificada) para uma possível ajuda.

Este interrupt() não tem efeito sobre a thread em execução, pois a thread a ser interrompida não faz uso de nada da APi de Threads que lance um InterruptedException (ex: Thread.sleep()).

Sei que poderia usar o Thread Pool do Java, com Executor, mas ainda não vi uma forma clara de fazer esse timeout da execução da tarefa.

Sugestões?

package test.thread.pool;

import java.util.ArrayList;
import java.util.List;

public class ThreadPoolTest {
	
	public static void main(String[] args) {
		ThreadPoolTest test = new ThreadPoolTest();
		test.go();
	}
	
	public void go() {
		ThreadPool pool = new ThreadPool(10);
		pool.start();
	}
	
	private class ThreadPool {
		
		private int maxThreads;
		private List<MyTask> threads = new ArrayList<MyTask>();
		
		public ThreadPool(int maxThreads) {
			this.maxThreads = maxThreads;
		}
		
		public void start() {
			for( int i=0; i<maxThreads; i++ ) {
				MyTask t = new MyTask(threads);
				threads.add(t);
				t.start();
			}
			
			TimeoutEnforcement timeout = new TimeoutEnforcement(threads);
			timeout.start();
		}
	}
	
	private class MyTask extends Thread {
		private long start = -1;
		private boolean running = false;
		private List><MyTask> threads;
		
		public MyTask(List<MyTask> threads) {
			this.threads = threads;
		}
		
		public void run() {
			running = true;
			start = System.currentTimeMillis();
			
			int rand = (int) (Math.random() * 10) * 10000;
			System.out.println( this.getId()+": "+rand );
			try {
				process(rand);
				System.out.println( this.getId()+": FINISHED" );
				
			} catch(Exception e) {
				System.err.println(this.getId()+": error" );
				e.printStackTrace();
			} finally {
				this.threads.remove(this);
				running = false;
			}
		}
		
		public void process(int value) throws InterruptedException {
			String a = "";
			for(int i=0; i<value; i++) {
				a += " ";
				// INTERRUPT SÓ FUNCIONA COM ESTA LINHA
				//Thread.sleep(1);
			}
		}

public long getStart() {
			return start;
		}

public boolean isRunning() {
			return running;
		}
	}
	
	private class TimeoutEnforcement extends Thread {
		
		private List><MyTask> threads;
		
		public TimeoutEnforcement(List<MyTask> threads) {
			this.threads = threads;
		}
		
		public void run() {
			System.out.println("*** TimeoutEnforcement STARTED ***");
			while( threads.size() > 0 ) {
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
				}
				System.out.println("*** TimeoutEnforcement RUNNING ***");
				
				for( MyTask t: threads ) {
					
					if( !t.isRunning() || t.getStart()<0 ) {
						continue;
					}
					
					long now = System.currentTimeMillis();
					long elapsed = now - t.getStart();
					
					if( elapsed > 2000 ) {
						t.interrupt();
						System.out.println("INTERRUPTED: "+t.getId());
					}
				} //for()
			} //while()

System.out.println("*** TimeoutEnforcement FINISHED ***");
		}
	}

}

denisdwtg wrote:O que quiseram fazer aqui????

Avisa que existe o break.

Bom, fiz uma gambiarra aqui e funcionou no meu caso.

Mas ainda procuro a solução correta.

Olhei a documentação mas não achei nada direto que me explica como pegar uma mensagem i18n dentro de um Controller do vRaptor 3.

Só achei referência usando um Validator, que não é o meu caso.

Algo que eu possa injetar no Controller para me dar esta informação que configura no messages.properties?

g4j wrote:Pasmem... Peguei um cara ensinando outro a fazer um método retornar 2 valores, rsrsrs retornava um Object[]

Melhor que isso.. só isso: http://www.guj.com.br/java/234881-ondemand---novo-design-pattern

Simplesmente uso Long como id e não uso mais relacionamentos persistentes, só faço referência às "FKs". E ai carrego na "mão" os objetos relacionados.

Estou meio que apanhando para fazer simples relacionamentos de entidades na minha aplicação com JPA para rodar no Google App Engine (GAE).

Um simples caso de relacionamento 1-N está virando um inferno.

Descobri que não posso usar chaves do tipo Long para classes relacionadas, então passei a usar Key.

Porém, no caso acima tomei uma exceção que pede que eu crie o ProductGroup com um "parent" para o seu key, já que estou associando a um Product. Ou seja, o relacionamento, obrigatoriamente, tem de ser OWNED.

Uma coisa simples, fica difícil de se fazer.

Neste caso, estou pensando em abrir mão de usar relacionamentos entre objetos e usar as classes como simples estrutura de dados.

Terei de fazer "JOIN" e sumarização (sum, avg, etc) na mão. Me parece deselegante, do ponto de vista do design, mas, talvez, uma simples solução para não me matar a cada hora descobrindo as restrições do GAE com o seu BigTable / Datanucleus.

Alguém sugere uma outra solução viável?

Opa, legal. Extender DefaultPathResolver resolveu meu problema. Valeu pela ajuda.
Aliás, poderiam incluir na documentação o fato de @Path e etc inibir o método citado acima.

Dá uma olhada aqui: http://www.guj.com.br/java/33085-genericdao

ÓTIMO controle de transações.

Notícias, artigos e o maior fórum brasileiro sobre Java