Multithreading i java

Her er der et lidt grimt forsøg:

 import java.util.concurrent.Executors;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
 import java.util.concurrent.Callable;
 import java.util.List;
 import java.util.LinkedList;
 
 public class T {
     public final static boolean isPrime(long num) {
         if (num < 2) return false;
         if (num == 2) return true;
         if (num % 2 == 0) return false;
 
         double sqrt = Math.sqrt(num);
         for (double i = 3; i <= sqrt; i += 2) {
             if (num % i == 0) {
                 return false;
             }
         }
         return true;
     }
 
     private static class PrimaliteTesterCallable implements Callable<List<Long>> {
         private final long first;
         private final long last;
 
         public PrimaliteTesterCallable(long first, long last) {
             this.first = first;
             this.last = last;
         }
 
         public List<Long> call() {
             List<Long> result = new LinkedList<Long>();
             for (long num = first; num <= last; num++) {
                 if (isPrime(num)) {
                     result.add(num);
                 }
             }
             return result;
         }
     }
 
     public static void main(String[] args) throws Exception {
         int i = 0;
         List<Future<List<Long>>> results = new LinkedList<Future<List<Long>>>();
         ExecutorService pool = Executors.newFixedThreadPool(10);
 
         for (long l = 0; l <= 1000000; l += 1000) {
             Future<List<Long>> result = pool.submit(new PrimaliteTesterCallable(l, l + 999));
             results.add(result);
         }
 
         for (Future<List<Long>> result : results) {
             List<Long> primes = result.get();
             for (Long prime : primes) {
                 System.out.print(String.format("%9d  ", prime));
                 if (++i % 10 == 0) {
                     System.out.println();
                 }
             }
         }
     }
 }

Hver Callable objekt tester 1000 tal og returnerer en liste af dem, som er primtal. Jeg smider en masse af disse callables efter en threadpool, og for hver callable får jeg et Future objekt retur.

Disse Future objekter smider jeg i en liste i den rækkefølge, de oprettes i. Efterfølgende venter jeg på, at den første bliver færdig og udskriver dens resultat. Derefter fortsætter jeg med den næste, og bliver ved på den måde, til alle opgaverne er løst.

Det kan nok gøres kønnere, men det må du selv klare...håber det er til at gennemskue.

Her er der et lidt grimt forsøg:

Java kode 

 import java.util.concurrent.Executors;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
 import java.util.concurrent.Callable;
 import java.util.List;
 import java.util.LinkedList;
 
 public class T {
     public final static boolean isPrime(long num) {
         if (num < 2) return false;
         if (num == 2) return true;
         if (num % 2 == 0) return false;
 
         double sqrt = Math.sqrt(num);
         for (double i = 3; i <= sqrt; i += 2) {
             if (num % i == 0) {
                 return false;
             }
         }
         return true;
     }
 
     private static class PrimaliteTesterCallable implements Callable<List<Long>> {
         private final long first;
         private final long last;
 
         public PrimaliteTesterCallable(long first, long last) {
             this.first = first;
             this.last = last;
         }
 
         [b]public List<Long> call() {
             List<Long> result = new LinkedList<Long>();
             for (long num = first; num <= last; num++) {
                 if (isPrime(num)) {
                     result.add(num);[/b]
                 }
             }
             return result;
         }
     }
 
     public static void main(String[] args) throws Exception {
         int i = 0;
        [b] List<Future<List<Long>>> results = new LinkedList<Future<List<Long>>>();
         ExecutorService pool = Executors.newFixedThreadPool(10);[/b]
 
         [b]for (long l = 0; l <= 1000000; l += 1000) {
             Future<List<Long>> result = pool.submit(new PrimaliteTesterCallable(l, l + 999));
             results.add(result);[/b]
         }
 
         [b]for (Future<List<Long>> result : results) {
             List<Long> primes = result.get();
             for (Long prime : primes) {
                 System.out.print(String.format("%9d  ", prime));
                 if (++i % 10 == 0) {
                     System.out.println();[/b]
                 }
             }
         }
     }
 }

Hver Callable objekt tester 1000 tal og returnerer en liste af dem, som er primtal. Jeg smider en masse af disse callables efter en threadpool, og for hver callable får jeg et Future objekt retur.

Disse Future objekter smider jeg i en liste i den rækkefølge, de oprettes i. Efterfølgende venter jeg på, at den første bliver færdig og udskriver dens resultat. Derefter fortsætter jeg med den næste, og bliver ved på den måde, til alle opgaverne er løst.

Det kan nok gøres kønnere, men det må du selv klare...håber det er til at gennemskue.

Hej,

tak for hjælpen først og fremmest - jeg påskønner virkelig din tid og insats - hvor er det dejligt at hjemmesider som udvikleren.dk kan hjælpe mig til at forstå java.

Jeg har dog et par spørgsmål til din kode som jeg håber du kan hjælpe mig med at klargøre.

Hvad mener du med gøres kønnere? Med henblik på hvilken del af koden?

Koden virker fint når jeg compiler i netbeans, men jeg har stadig nogle spørgsmål til de enkelte dele af koden og derfor ville det være en stor hjælp hvis du kunne lave nogle kommentarer til mig i de kodestykker jeg har fremhævet.

Kravet til opgaven er at implementere thread-klassen eller at implementere runnable interfacen.

Derudover kan vi implementere runnable-interfacen og bruger run-metoden. Jeg har læst mig frem til at runnable er et supplement til callable så har du mulighed for at lave dette om i koden således at du bruger runnable og indfører run-metoden i stedet for callable og call-metoden??

Endnu en gang stor tak for hjælpen

Vh Emilie


/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package threading;

/**
*
* @author emiliebalslev
*/
class MyRunnable implements Runnable{
private int a;

public MyRunnable(int a){
this.a = a;
}

@Override
public void run(){
for (int i = 1; i <= a; ++i){
System.out.println(Thread.currentThread().getName() + " is " + i);
try{
Thread.sleep(1000);
}
catch (InterruptedException e){}
}
}
}

class MaiMyThread{
public static void main(String args[]){
MyRunnable thr1, thr2;
thr1 = new MyRunnable(5);
thr2 = new MyRunnable(10);
Thread t1 = new Thread(thr1);
Thread t2 = new Thread(thr2);
t1.start();
t2.start();
}
}
(det er i dette format jeg ønsker min flertrådede applikation skal være)

Jeg kalder min løsning for "grim" fordi, den bruger "magiske" konstanter, ikke tilbyder et pænt og brugbart API, og fordi den er for kompakt (efter min mening). Det er ret subjektive målepunkter, så ikke alle ville være helt enige. However, det var bare for at illustrere brugen af thread pools og callables, så med det i mente, så mener jeg, at løsningen var god nok.

Hvis vi giver dig den fulde løsning (den du selv bad om), så gør vi dig en bjørnetjeneste, for det er en skoleopgave, og det er meningen, at du skal svede over den selv...hvis du gør det, så får du meget ud af arbejdet, uanset om du ender med en brugbar løsning. Nogle af mine bedste og mest lærerige timer gik på at lave fejl på fejl på fejl, så jeg vil stærkt opfordre dig til at slide videre selv...tråd programmering ér svært!

Men her er et par pointere.

Lad være med at tænke på opgaven som kode. Det er ikke tråde, men mennesker, som du skal sætte i arbejde. Du selv tager opgaven som "hovedtråden". Du har fire kammerater, som er dine "arbejdertråde".
Dine fire kammerater står ved et transportbånd (en java.util.concurrent.BlockingQueue), hvor du (hovedtråden) lægger opgaver (queue.put(new Assignment())). Dine kammerater tager så opgaver fra transportbåndet (queue.take()), og arbejder på dem.

Når du har lagt disse opgaver på transportbåndet, så går du hen til kassen (endnu en java.util.concurrent.BlockingQueue), hvor dine kammerater lægger resultatet af deres arbejde. Du tager så deres resultater, efterhånden som de dukker op (de kommer sandsynligvis ikke i rigtig rækkefølge), og efterprocesserer dem (lægger dem i rækkefølge og skriver dem ud).

Alle dine kammerater udfører samme type opgave, så deres instruktion kan nedfældes i en klasse, som implementerer Runnable.

Så det du skal bruge er to instanser af BlockingQueue, en klasse som implementerer Runnable, og som kan tage opgaver fra én BlockingQueue. Opgaven skal indeholde informationer om, hvilke tal, som skal testes for om de er primtal (first og last). Resultatet kan være en List<Long> som så smides i den anden BlockingQueue.

Der er mange måder at løse opgaven på, men hvis du tænker i analogier som den ovenstående, så kan du meget lettere visualisere en løsning. Sådan gør jeg selv konstant.

Håber det fik dig lidt videre, ellers så spørg til noget konkret...ikke "giv mig en fuld løsning".

Jeg forstår godt din analog, men jeg er i tvivl omkring hvordan jeg opretter denne liste af resultater.


Skal jeg deklarere et felt med en variable som tager datatypen "Long" og så indsætte specifikke værdier som er alle primtal fra f.eks. 0-1000 på forhånd når jeg instantierer feltet i en konstruktor?

Du kan gøre ca. som i den løsning, jeg postede. Et objekt med en range, og så er resultatet en liste af Long objekter, som alle er primtal.

Altså noget i stil med:

 private final static class Assignment {
         private long first;
         private long to;
         private List<Long> result;
 
         public Assignment(long first, long to) {
             this.first = first;
             this.to = to;
             this.result = null;
         }
 
         public synchronized void solve() {
             //Find alle primtal fra 'first' til 'to'
             //Tilføj dem til 'result'
         }
 
         public synchronized List<Long> getSolution() {
             //Vent på at 'result' ligger klar
             //Returner den derefter
         }
     }

Din hovedtråd kan instantiere en række objekter af ovenstående klasse og give dem til et par tråde, som kan tygge på dem.
Derefter kan hovedtråden så hente løsningen ud af hvert objekt og udskrive resultatet.

Okay vil du uddybe hvordan jeg skal bygge min hovedtråd op så den kan instantiere disse objekter?
Skal jeg oprette en klasse som extends fra Thread-klassen hvori jeg opretter en række objekter med tråde?


/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package threading;

/**
*
* @author emiliebalslev
*/
class MyRunnable implements Runnable{
private int a;

public MyRunnable(int a){
this.a = a;
}

@Override
public void run(){
for (int i = 1; i <= a; ++i){
System.out.println(Thread.currentThread().getName() + " is " + i);
try{
Thread.sleep(1000);
}
catch (InterruptedException e){}
}
}
}

class MyThreads{
public static void main(String args[]){
MyRunnable thr1, thr2;
thr1 = new MyRunnable(5);
thr2 = new MyRunnable(10);
Thread t1 = new Thread(thr1);
Thread t2 = new Thread(thr2);
t1.start();
t2.start();
}
}


På den samme måde som i dette eksempel, men hvor jeg indsætter felterne "first", "to" og "result" på samme måde som jeg har indsat feltet a?

Jeg er også i tvivl om hvordan jeg kan lave hente listen ind i min run-metode på samme måde som du har gjort i den call-metode. Problemet er jo nemlig at list<Long> ikke er brugbare med et void-return statement

Tjoeh tjah...jeg ved ikke hvad 'a' repræsenter i din kode, men alle tråde er sat til at løbe fra 1 til 'a'. Jeg tror, at 'a' er hvad jeg kalder 'to' i min 'Assignment' klasse, men du har ikke en 'first', som er det første tal, som skal testes for om det er et primtal. Bare smid det med som parameter til MyRunnable klassens constructor.

Runnable kan ikke returnere noget, så den er nødt til at generere et resultat, som det kan levere til hovedtråden, måske via en liste...eller man kan gøre noget lidt andet :-)

Hvis du kigger i min Assignment klasse, så har jeg lagt op til en anden løsning. Der er en 'solve()' metode og en 'getSolution()' metode. De er begge synchronized. 'getSolution()' skal tjekke, om løsningen foreligger, og hvis den gør, så bare returnere den. Hvis ikke, så skal den vente (Object.wait()) på, at løsningen bliver lavet.

'solve()' metoden laver så løsningen, og når den er færdig, så fortæller den det til alle interesserede (Object.notifyAll()).

De er ikke implementerede, men det kan du selv gøre, hvis du vil gå efter den løsning.

Hovedtråden kan lave en række af disse Assignment objekter og ligge hver i en liste, som den selv kan iterere over senere. De bliver også lagt i en kø, som et par arbejder tråde kan tømme.

Tror det er det nemmeste, hvis man absolut skal bruge Runnable :-)