Anfänger Thread Frage

[afurtenbacher]

Hallo zusammen!

Ich habe mir einen kleinen Server geschrieben, der an sich gute Arbeit leistet. Der einzige Haken der mich stört ist, daß das ganze Teil in einem einzigen Thread läuft. Ergo hilft mir der brave kleine Dual-Core Prozessor nicht wirklich. Da ich den natürlich gerne ausnützen würde, hätte ich gerne gewußt wie man richtig Multi-threaded.

Wie ein Thread an sich funkt ist mir denke ich klar. ABER: Ich habe zb eine Klasse die mir die Lesezugriffe auf die DB übernimmt, welche hptsl static Methoden beinhaltet. Wie kann ich das nun am besten jede einzelne Methode als eigenen Thread laufen lassen? Soviel ich bis jetzt von Threads gelesen habe, braucht es immer eine Klasse mit einer run() Methode. Funkt das auch wenn ich mehrere class in ein File schreibe? Davon bin ich eigentlich kein wirklicher Fan, da es den Code meines Erachtens unübersichtlich macht. Wie macht man das richtig?

Vielen Dank für die Hilfe,
Andreas

[fallout boy]

Hallo Andreas,
ein Thread wird wie folgt erstellt.

Als erstes entwicklest Du dir eine Klasse die von der Klasse "Thread" erbt.
Danach implementierst Du die methode "public void run()" in die Klasse.
Um diesen Thread ausführen zu können erzeugst Du in der main-Methode,
deines Haupt-Klasse, eine neues Objekt vom Typ Deiner Thread-Klasse und
kannst es dann per nameDesObjekts.start() aufrufen. Die Methode "start()" ruft
die Methode "run()" in Deiner Thread-Klasse auf und führt sie aus.

Hier mal ein kleines Bsp.


MyThread-class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
[COLOR="DarkRed"]package[/COLOR] de.tutorials.thread
 
[COLOR="Green"][I]//erbt von Thread[/I][/COLOR]
[COLOR="DarkRed"]public class[/COLOR] MyThread [COLOR="DarkRed"]extends[/COLOR] Thread {
 
    
    [COLOR="DarkRed"]public[/COLOR] MyThread() {
        
    }
 
    [COLOR="DarkRed"]public void[/COLOR] run() {
        System.[COLOR="RoyalBlue"]out[/COLOR].println([COLOR="RoyalBlue"]"Hier läuft mein Thread!"[/COLOR]);
    }
    
}

TestThread-class

1
2
3
4
5
6
7
8
9
10
11
12
13
[COLOR="DarkRed"]package[/COLOR] de.tutorials.thread
 
[COLOR="DarkRed"]public class[/COLOR] TestThread {
 
    [COLOR="DarkRed"]public static void[/COLOR] main(String[] args) {
            [COLOR="Green"][I]//erzeugen des Thread[/I][/COLOR]
        MyThread meinThread = [COLOR="DarkRed"]new [/COLOR]MyThread();
                MyThread meinThread2 = [COLOR="DarkRed"]new[/COLOR] MyThread();
                [COLOR="Green"][I]//Thread starten[/I][/COLOR]
                meinThread.start();
                meinThread2.start();
    }
}

Eine weitere Möglichkeit ist es eine Klasse zu erstellen, die das Interface Runnable
implementiert.
Das funktionert fast genau so, außer dass man das Objekt, das Runnable implementiert,
an den Konstruktor eines neuen Thread-Objectes übergeben muss.

1
2
3
4
5
[I][COLOR="Green"]//Object erzeugen vom eigenen Typ der Klasse die Runnable implem. [/COLOR][/I] 
ThreadImplemetiertRunnable myThread = [COLOR="DarkRed"]new[/COLOR] ThreadImplemetiertRunnable();
                 [I][COLOR="Green"]//Objekt an den Konstruktor des neu Threadobjekts übergeben[/COLOR][/I]
        Thread t = new Thread(myThread);
                t.start();

Ich hoffe, ich konnte es erstmal einigermaßen verständlich erklären.

MfG

fallout boy

[afurtenbacher]

hallo fallout boy!

Danke erstmal für deine Hilfe!
Wie man einzelne Threads schreibt habe ich kapiert. ABER: so wie in deinem Bsp, kann ich ja immer nur eine einzige Methode als run() implementieren (als das was vorher die Methode gemacht hat in die run() verschieben). Ergo müsste ich ja für jede Methode von der ich will daß sie in einem eigenen Thread läuft eine eigene Klasse schreiben, die eine run() Methode hat, welche dann das macht was ich möchte.
Nun habe ich in meinem Programm wie erwähnt zb eine ReadData Klasse die diverse SELECT queries an die DB schickt und mir die Daten in verschiedener Form retourniert (einmal einen JTable, einmal ein einzelnes Objekt, etc). Wenn ich für jede dieser Methoden eine eigene Klasse schreiben muß, gehe ich ja unter in Klassen.

Ich hoffe du verstehst was ich meine

lg,
Andreas

[zerix]

Hallo,

du könntest auch einfach in jeder Methode einen neuen Thread starten

1
2
3
4
5
6
7
8
9
10
public void deineMethode(){
 
    new Thread(){
       public void run(){
          //mach irgendwas
       }
 
    }.start();
 
}

So kannst du es direkt in deine Methoden reinschreiben und brauchst nicht immer ne eigene Klasse zu schreiben.

Wenn man in der object-orientierten Programmierung richtig plant, dann hat man eine Menge Klassen, das lässt sich maximal durch Spaghetti-Code vermeiden.

MFG

zEriX

[MeinerEiner_80]

Moin!
Ist dir damit geholfen?

1
2
3
4
5
6
7
8
9
10
11
12
Thread t = new Thread(){
            public void run(){
                //code
            }
        };
 t.start();
t= new Thread(){
            public void run(){
                //andere code
            }
        };
 t.start();

Edit: Da war wohl jemand schneller

[afurtenbacher]

hehe

auch wenn ich spaghetti an sich mag, so habe ich gegen spaghetticode eine gewisse aversion *lach*

auf das mit den new Thread() bin ich noch nicht gekommen. ist das ordentlicher programmierstil, oder ist das eher pfusch. wenn ich schon was lerne, dann soll es auch was gscheites sein

wie macht ihr das? die eine klasse (die nur die lesezugriffe macht), hat immerhin satte 30 Methoden...

Edit: danke meinereiner!

lg,
Andreas

[zerix]

Ich kenne ja deinen Code nicht, aber ist es nicht Möglich, dass du die Daten an einer Stelle aus der Datenbank liest, die Beispielsweise in einer HashMap packst und dann deine GUI anhand der HashMap aktualisierst?

[Thomas Darimont]

Hallo,

Ab Java 5 sollte man sich angewöhnen Threads nicht mehr über new Thread(){ ... zu erzeugen (es sei denn man braucht Daemon-Threads...) sondern mit der ExecutorService / Executors Infrastruktur.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
/**
 * 
 */
package de.tutorials;
 
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
 
/**
 * @author Thomas.Darimont
 *
 */
public class ThreadCreationExample {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        System.out.println(executorService);
        Runnable runnable = new Runnable(){
            @Override
            public void run() {
                for(int i = 0; i< 10;i++){
                    System.out.println(i);
                    try {
                        TimeUnit.SECONDS.sleep(1L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        
        executorService.execute(runnable);
        
    }
 
}

Das hat dann den Vorteil, dass man die Threading/Scheduling/Pooling Konzepte einfacher konfigurierbar machen kann.
Siehe auch hier:
http://www-128.ibm.com/developerwork...j-jtp1126.html

Gruß Tom

[afurtenbacher]

Ich kenne ja deinen Code nicht, aber ist es nicht Möglich, dass du die Daten an einer Stelle aus der Datenbank liest, die Beispielsweise in einer HashMap packst und dann deine GUI anhand der HashMap aktualisierst?

das würde aber bedeuten daß ich jedes mal wenn ein client eine leseanfrage schickt, ich alle daten aus der db holen müsste. oder verstehe ich dich da falsch?

so gibt es zb eine methode getKundeByNummer(int nummer) etc.

@Thomas: und so ist das "state of the art"?

[zerix]

Ich hab dich so verstanden, dass jedes GUI-Element, eine Anfrage an die DB schickt, über deine DB-Klasse. Also wenn z.b. 3 Elemente gleichzeitig einen Kunden anzeigen, alle 3 eine Anfrage an die DB senden.

[afurtenbacher]

ach so. nein nein es wird eine query an die db geschickt, die erstellt das kunden-objekt, liefert dieses zurück und aus diesem werden die daten für die gui-elemente gelesen.

lg,
Andreas

[afurtenbacher]

noch eine frage zu den threads:

werden bei einer mehrprozessormaschine nur ganze prozesse auf die kerne verteilt, oder auch einzelne threads?

lg,
Andreas

[Thomas Darimont]

Hallo,

@Thomas: und so ist das "state of the art"?

IMHO ja.

Gruß Tom