preciso fazer um programa que some paralelo de 1 á 100 usando quatro threads
exemplo 1-25
26-50
51-75
76-100
final soma tudo
Algum pode me ajudar …Obrigado
Use o método “join” para esperar uma thread acabar.
não sei como fazer isto !!
não sei como fazer isto !![/quote]
Ok, e o que você tem feito?
Se já tiver iniciado, sugiro que poste o código.
Se não, sugiro que estude sobre threads:
http://java.sun.com/docs/books/tutorial/essential/concurrency/threads.html
Acho que ele não quer que uma thread acabe para que outra iniciei. Pelo que entendi são as quatro rodando sem prioridade definida.
Acho que ele não quer que uma thread acabe para que outra iniciei. Pelo que entendi são as quatro rodando sem prioridade definida.[/quote]
é isso mesmo mas não sei fazer o programa !!!
Acontece que, ao final da execução das trheads, o resultado de todas elas tem que ser somado. Mas como você vai fazer isso se houver pelo menos uma delas que ainda não terminou seu serviço? Nesse momento você precisa do join(), para esperar ela terminar de fazer as contas.
Acontece que, ao final da execução das trheads, o resultado de todas elas tem que ser somado. Mas como você vai fazer isso se houver pelo menos uma delas que ainda não terminou seu serviço? Nesse momento você precisa do join(), para esperar ela terminar de fazer as contas.[/quote]
diego como ficaria o codigo eu não sei fazer!!
vc pode me ajudar ???
Explicando melhor:
Você terá que escrever uma classe que herde de Thread e que receba dois inteiros no construtor: o valor inicial do intervalo a ser somado e o valor final. No método run, a thread somará todos os números do intervalo. E essa classe terá também um método getResult() que retornará o resultado do cálculo. Dentro desse método, é necessário chamar o join() para que o resultado só seja retornado quando a thread terminar sua execução.
Depois, é só instanciar quatro objetos dessa classe configurando os intervalos, somar o getResult() de cada uma e correr pro abraço.
Amigo, vou te dar uma ajuda, mas cuidado, não utilize palavras como “urgente”, “socorro”, “pelo amor de Deus” em seus posts, o pessoal não aprecia muito isso…
Qualquer coisa dá uma lida nesse post, vai te ajudar a como fazer um post…
Mas vamos lá, vou fazer uma implementação aqui. Primeiro estou sem o jkd, então o que eu postar pode estar errado. Segundo, o que eu postar pode não ser o correto, nem o que você precisa.
Deixemos de lorota e vamos ao código:
[code]public class Contador implements Runnable {
private int inicio;
private int fim;
public Contador(int inicio, int fim) {
this.inicio = inicio;
this.fim = fim;
}
public void run() {
for(i = inicio; i <= fim; i++) {
System.out.println(i);
}
}
}[/code]
[code]public class Teste {
public statis void main(String[] args) {
(new Thread(new Contador(1, 25))).start();
(new Thread(new Contador(26, 50))).start();
(new Thread(new Contador(51, 75))).start();
(new Thread(new Contador(76, 100))).start();
}
}[/code]
Espero que ajude…
T+
Acontece que, ao final da execução das trheads, o resultado de todas elas tem que ser somado. Mas como você vai fazer isso se houver pelo menos uma delas que ainda não terminou seu serviço? Nesse momento você precisa do join(), para esperar ela terminar de fazer as contas.[/quote]
É verdade, acho que não li direito o que ele queria…srsrr
De qualquer forma, o código que postei serve de exemplo… :lol:
[quote=diego2005]É verdade, acho que não li direito o que ele queria…srsrr
De qualquer forma, o código que postei serve de exemplo… :lol:[/quote]
Sem problema, é só pegar o código que você postou e botar o método getResult() conforme expliquei no meu post anterior e fazer a classe herdar thread ao invés de implementar runnable.
Acontece que, ao final da execução das trheads, o resultado de todas elas tem que ser somado. Mas como você vai fazer isso se houver pelo menos uma delas que ainda não terminou seu serviço? Nesse momento você precisa do join(), para esperar ela terminar de fazer as contas.[/quote]
É verdade, acho que não li direito o que ele queria…srsrr
De qualquer forma, o código que postei serve de exemplo… :lol:
Desculpas pelo o urgente não irei fazer mais isso, obrigado pela ajuda valew mesmo.
o que eu preciso mesmo que o programa some em paralelo usandos 4 thread e depois some as quatros tem como fazer isso eu nao sei ???
[/quote]
package javaapplication41;
public class Main {
public static void main(String[] args){
try{
ARun a = new ARun(0);
Thread t1 = new Thread(a);
t1.start();
synchronized (t1){
t1.wait();
}
ARun b = new ARun(a.getInt());
Thread t2 = new Thread(b);
t2.start();
synchronized (t2){
t2.wait();
}
ARun c = new ARun(b.getInt());
Thread t3 = new Thread(c);
t3.start();
synchronized (t3){
t3.wait();
}
ARun d = new ARun(c.getInt());
Thread t4 = new Thread(d);
t4.start();
synchronized (t4){
t4.wait();
}
System.out.println("\nA soma total eh: " + a.getInt());
}
catch(Exception e){
e.printStackTrace();
}
}
}
class ARun implements Runnable{
private static int i;
public ARun(){}
public ARun(int b){
i = b;
}
public void run(){
metodo(i);
}
public void metodo(int c){
synchronized(this){
for(int a = 0; a < 25; a++){
i++;
System.out.print(i + " ");
}
notify();
}
}
public void setInt(int i){
this.i = i;
}
public int getInt(){
return i;
}
}[quote=tnaires]Explicando melhor:
Você terá que escrever uma classe que herde de Thread e que receba dois inteiros no construtor: o valor inicial do intervalo a ser somado e o valor final. No método run, a thread somará todos os números do intervalo. E essa classe terá também um método getResult() que retornará o resultado do cálculo. Dentro desse método, é necessário chamar o join() para que o resultado só seja retornado quando a thread terminar sua execução.
Depois, é só instanciar quatro objetos dessa classe configurando os intervalos, somar o getResult() de cada uma e correr pro abraço.[/quote]
Será que poderia postar o codigo para mim ???
Valew
[quote=jho_2009]Será que poderia postar o codigo para mim ???
Valew[/quote]
Tudo bem. Vou aplicar as modificações que estou falando na solução do Diego.
[code]public class Contador extends Thread {
private int inicio;
private int fim;
private int result;
public Contador(int inicio, int fim) {
this.inicio = inicio;
this.fim = fim;
}
public void run() {
for(int i = inicio; i <= fim; i++) {
result += i;
}
}
public int getResult() {
try {
this.join();
} finally {
return result;
}
}
}[/code]E na classe que contém o método main:
[code]public class Teste {
public static void main(String[] args) {
Contador c1 = new Contador(1, 25);
Contador c2 = new Contador(26, 50);
Contador c3 = new Contador(51, 75);
Contador c4 = new Contador(76, 100);
c1.start();
c2.start();
c3.start();
c4.start();
System.out.println("Resultado: " + (c1.getResult() + c2.getResult() + c3.getResult() + c4.getResult()));
}
}[/code]
Pronto, agora você tem duas soluções pro seu problema. Escolha a que lhe parecer melhor.
E não vá se acostumando não, não é sempre que a solução aparece prontinha assim no GUJ. O ideal seria você estudar threads e fazer por si mesmo.
[quote=tnaires][quote=diego2005]É verdade, acho que não li direito o que ele queria…srsrr
De qualquer forma, o código que postei serve de exemplo… :lol:[/quote]
Sem problema, é só pegar o código que você postou e botar o método getResult() conforme expliquei no meu post anterior e fazer a classe herdar thread ao invés de implementar runnable.[/quote]
Porque não implementar Runnable???
Apenas por conveniência, já que o método join() está em Thread e não em Runnable.
Se quiser manter a interface, o método join() terá que ser chamado no método main.
Assim ó:
[code]public class Teste {
public statis void main(String[] args) {
Contador c1 = new Thread(new Contador(1, 25));
Contador c2 = new Thread(new Contador(26, 50));
Contador c3 = new Thread(new Contador(51, 75));
Contador c4 = new Thread(new Contador(76, 100));
c1.start();
c2.start();
c3.start();
c4.start();
c1.join();
c2.join();
c3.join();
c4.join();
System.out.println("Resultado: " + (c1.getResult() + c2.getResult() + c3.getResult() + c4.getResult()));
}
}[/code]
Alguém pelo menos testou o código que postei?!
Ué, você não? :XD:
Brincadeira, eu falei no meu post anterior que o autor do tópico agora tem duas soluções, e quando eu falei isso me referi à sua.