Mensagens enviadas por: rflprp

[]´s

Tava precisando mesmo tirar um pouco da ferrugem em threads, segue um código que fiz aqui pra exemplificar o funcionamento.

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

/**
 * Classe que efetua uma busca paralela em um array de inteiros.
 *
 * @author Rafaelprp
 * @date 31/05/2008
 */
public class TesteMain {

/**
	 * Aqui que começa a mágica.
	 */
	public static void main(String[] args) {

//Quanto mais itens, mais claro fica o comportamento paralelo das threads.
		final int QUANTIDADE_ITENS = 20000;

//Geração do array de itens únicos pode demorar bastante.
		//Uma boa ideía é gerar um array bem grande, que demora uns 5 minutos
		//e depois serializar ele prum txt, e depois só ficar
		//utilizando ele.
		final boolean ITENS_UNICOS = true;
		final int QTD_THREADS = 10;
		final int VALOR_PROCURADO = 12436;

long time = System.currentTimeMillis();

Object[] array = getArray(QUANTIDADE_ITENS, ITENS_UNICOS);

time = (System.currentTimeMillis() - time);

System.out.println("######################");
		System.out.println("Tempo para criação do array: " + time + " ms");
		System.out.println("######################\n");

// só agora começa a busca.
		buscar(QTD_THREADS, array, VALOR_PROCURADO);
	}

/**
	 * Monta um array de inteiros de 0 a *total*, com ou sem elementos
	 * repetidos. Este método é opcional, só é usado par simular um array
	 * heterogêneo.
	 *
	 * Dependnedo da quantidade de itens, esse método quando for executado para
	 * gerar um array de itens únicos, pode demorar bastante...
	 */
	private static Object[] getArray(int totalElementos, boolean itensUnicos) {

List<Integer> lista = new ArrayList<Integer>();
		Random rand = new Random();

while (lista.size() < totalElementos) {
			Integer num = rand.nextInt(totalElementos);

if (!itensUnicos || !lista.contains(num)) {
				lista.add(num);
			}
		}

return lista.toArray();
	}

/**
	 * Efetua a busca.
	 *
	 * @param qtdThreads -
	 *            Quantidade de threads que vc quer usar.
	 * @param array -
	 *            Array com os itens da busca.
	 * @param target -
	 *            Target procurado.
	 */
	private static void buscar(int qtdThreads, Object[] array, Object target) {

// Aproximadamente quantos itens do array serão vasculhados por thread.
		int itensPorThread = (int) Math
				.ceil((double) array.length / qtdThreads);

// Todas as threads pertencerão a esse grupo, isso é com para controle.
		ThreadGroup group = new ThreadGroup("ThreadGroup Busca");

int inicio = 0;
		int fim = itensPorThread;

List<Thread> threadList = new ArrayList<Thread>();

// Configuro as threads.
		for (int i = 0; i < qtdThreads; i++) {

if (fim >= array.length) {
				fim = (array.length - 1);
			}

Runnable runnable = new BuscaParalela(array, target, inicio, fim);

threadList.add(new Thread(group, runnable, "T" + i));

inicio = ++fim;
			fim += itensPorThread;

}

long time = System.currentTimeMillis();
		// Inicio as threads
		fire(threadList);
		time = (System.currentTimeMillis() - time);

System.out.println("\n######################\n"
				+ "Tempo decorrido na busca com : " + qtdThreads + " threads: "
				+ time + " ms" + "\n######################\n");
	}

/**
	 * Inicia as threads já configuradas.
	 */
	private static void fire(List<Thread> threads) {
		for (Thread thread : threads) {
			thread.start();
		}
	}
}

/**
 * Essa é a classe que roda em cada thread, ela quem faza busca. Outro método de
 * busca mais eficaz poderia fácilmente ser usado, utilizei a busca sequencial
 * pois não é o foco do programa.
 */
class BuscaParalela implements Runnable {

private Object[] array;
	private Object target;
	private int inicio, fim;

/**
	 * Construtor.
	 *
	 * @param array -
	 *            Array contendo todos os itens.
	 * @param target -
	 *            O target que deve ser encontrado.
	 * @param inicio -
	 *            O início da área de busca dessa instância.
	 * @param fim -
	 *            O fim da área de busca dessa instância.
	 */
	BuscaParalela(Object[] array, Object target, int inicio, int fim) {
		this.array = array;
		this.target = target;
		this.inicio = inicio;
		this.fim = fim;
	}

/**
	 * Efetua a busca.
	 */
	public void run() {

System.out.println("Iniciando busca de " + inicio + " - " + fim);

for (int i = inicio; i <= fim; i++) {
			if (target.equals(array[i])) {
				System.out.println("\n######################\n" + "'" + target
						+ "' achado na posição " + i + " pela thread '"
						+ Thread.currentThread().getName() + "'"
						+ "\n######################\n");
				// Matar as outras threads do grupo, opcional.
				// Thread.currentThread().getThreadGroup().interrupt();
				return;
			}
		}

System.out.println("Thread '" + Thread.currentThread().getName()
				+ "' terminou a busca sem sucesso.");
	}
}

[]´s

Leozin wrote:tenho estudado economia e filosofia

+ história

[]´s

tô precisando formatar um número completando zeros a esquerda dele, só que não acho q referência de patterns da jstl em lugar nenhum....

Alguém sabe onde posso arrumar?

[]´s

vê se teu xp tá com firewall ativado.

[]'s

hehe me expressei mal, quando disse pesado, quis dizer difícil... a sintaxe do swing é bem chata...

Cara usa u Visual Editor do eclipse, sempre prefiri ele ao netbeans...

[]´s

Você está usando o que ? Swing ?

Se for, o que normalmente faço é (não lembro toda a sintaxe de cabeça):

- Se aquela ação só for utilizada alí, utilizo uma classe anônima: btn.addActionListener(new ActionListener() { .... });

- Agora actions utlizados em vários lugares, como botões de voltar, sair, etc... eu mantenho eles de forma estática e injeto onde for necessário, normalmente na criação de painéis....

PS: Swing sem IDE é meui pesado cara.... escolha uma IDE e cai dentro.

[]´s

Cara, arquiteturas engessadas são um grande problema, mas já que o seu problema é entender uma já definida, normalmente usam essa arquitetura da seguinte forma:

1 - Solicitação HTTP recebida pelo ActionServlet do struts e delegada ao seu Action.

2 - No action você vai chamar o Business Delegate, opcionalmente passando um Value Object com os dados

3 - O Business Delegate vai chamar o Service Locator para obter a referência do EJB, opcionalmente o service locator pode fazer cache dela.

4 - Uma vez com a referência do EJB, você invoca o método desejado, opcionalmente passando o VO como parâmetro.

5 - No seu EJB, que provavelmente é um Stateless Session Bean (ou uma session façade, pra sair bem na foto) você vai pegar a referência do DAO e invoca-lo.

6 - Agora é só retornar tudo até la em cima.

Só lembrando:

- No action: Só logica de receber dados do usuário e exibir uma resposta, nada de passar o form pras camadas de baixo, crie um VO e repasse (o Dozer ajuda bastante com VO´s e forms parecidos). Sem nenhuma regra de negócio aqui.

- No Business delegate: Essa camada só server para você localizaro responsável pelo processo de negócio (EJB) invocar o processo. Tem business no nome mas nada de negócio aqui.

- No service locator: Aqui você só pega a referência do EJB via JNDI... JNDI só aqui, nada de fazer lookups em outros lugares... aqui você pode fazer cache das referências (pra stateless).

- No EJB : Aqui é que você orquestra a transação. Aqui fica centralizada a regra de negócio.

- No DAO, só acesso a banco, nada de um if "rs.getInt(1) == 0" pra verificar regras, isso tem que estar no EJB.

Bom, acho que no mais é isso aí cara... essa arquitetura é bem ultrapassada mas ainda tem muita gente socando isso em tudo quanto é sistema...

Espero que tenha tirado suas dúvidas,

[]´s

EX:

Tenho meu sistema web, com todas as minahs transações, etc..

Em um determinado momento preciso chamar um processo batch, ou chamar um procedure cabeluda... ou seja, algo que vá demorar ou que simplesmente o meu sistema não precise ficar esperando a conclusão da operação.

Aí você manda uma mensagem, de forma assíncrona, do lado da sua aplicação ele só fala pro seu Message Bean: "Se vira aí ".... aí o seu Message Bean diz pra ele "deixa comigo"... sua aplicação segue seu fluxo normalmente sem depender do processo e seu message bean começa a ralar...

Chamadas assíncronas e baixo acoplamento são só 2 vantagens da API de mansagens, uso de mensagens é uma ferrameta muito poderosa, tem um livro "Java Messaging" se não me engano, lí alguns pedaços do pdf e achei muito bom.

Vale a pena dar uam lida.

[]´s

nada.... instalei o weblogic 10....

alguém tem algum documento explicando como montar esse ambiente??

[]'s

é... acho q não vai ter jeito...

beleza então cara, valeu a ajuda!

[]´s

Luca,

Baixei o "BEA WebLogic® Real Time" aqui, instalei a jrockit, tudo beleza..... mas não consigo achar o raio do jar que tem as classes do javax.realtime ....
eu ví que juntp do weblogic vem um wl-realtime.jar ..... será que vou ter q baixar essa nave mãe toda só pra pegar um jarzinho ???

valeu,

Luca wrote:Olá

Uma pergunta:
O que pretende fazer com Real Time?

[]s
Luca

Passar na entrevista

value cara, vou dar uma olhada nos links.

abs,

Buenas,

Tô precisando dar um estudada na parte de real time do java (JSR-1).

Achei várias implementações, mas nenhuma pra windows... to baixando o ubuntu aqui na esperança de que rode na boa.... mas ter que ficar fazendo dual boot é um saco... e usar um vmware da vida só pra isso vai ser triste.....

Alguém conhece alguma implementação pra windows, ou que eu possa compilar nele na boa???

Valeu.

dá uma olhada nas provas de soa da ibm.

[]´s

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