Threads und Nebenläufigkeit

[micbur]

Hallo,

ich will verschiedene Threads erzeugen, die gleichzeitig laufen können und sich ggf auch Daten schicken.

Also aus C kenne ich fork(). fork() kehrt nicht mehr zum Elternprozess zurück, sodass ein Elternprozess sich derweilen auch schonmal um etwas anderes kümmern kann, während der Kindsprozess sich irgendwelchem Käse hingibt. hier wartet der Kindsprozess einige Zeit (vorerst).

Irgendwie klappt das aber in Java nicht so recht.
Ich erzeuge zwar je einen neuen Thread mit 'new Thread', aber erst, wenn der Thread fertig ist, werden die nächsten zeilen im Programmablauf abgearbeitet.

habe ich was falsch gemach oder geht das in Java gar nicht?

Ciao micbur

 

[L-ectron-X]

Zu jedem Thread "gehört" eine run()-Methode, die überschrieben werden muss. Die Methode enthält den Code, den der Thread zu seiner Laufzeit ausführen soll. Threads werden mit start() gestartet. Nur eine Instanz von Thread erzeugen reicht da nicht.

 

[Thanni]

selbst wenn man einen paralell laufenden thread hat ist das doch kein process oder ?

ich würde sagen das wenn das programm beendet wird auch alle threads beendet werden und nicht wie bei einem kindprocess weiterlaufen oder irre ich mich da ?

ok das mit dem beenden war nicht die frage aber ich würde schon gerne wissen ob man einen kindprocess erzeugen kann in java

gruß thanni

[edit] vielleicht mit static? [/edit]

 

[Grizzly]

@Thanni: Nein, static hat damit nichts zu tun.

Java unterstützt - soviel ich weiss - nur Threads. Einen Kind-Prozess kann man nur erzeugen, in dem man ein neues Programm mit bspw. exec(String[] cmdarray) (Klasse Runtime) startet.

Wenn Du in Java einen Thread Dir basteln willst, geht das in etwa so:
Ersteinmal bastelst Du eine Klasse, die nachher arbeiten soll:

public class Worker implements Runnable {
	/**
	 * Dies ist der Standard Konstruktor.
	 */
	public Worker() {
		super();
	}
	
	/**
	 * Diese Methode führt die Arbeit aus.
	 * Siehe auch {@link http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Runnable.html}.
	 */
	public void run() {
		// Pruefen, ob Thread beendet werden soll.
		while (!Thread.interrupted()) {
			System.out.println('A');
			try {
				// 1 Sekunde warten.
				Thread.sleep(1000);
			} catch (InterruptedException ie) {
				// Wenn der Thread waehrend des Wartens den Befehl zum Beenden erhaelt.
			}
		}
	}
}

Und schließlich die Hauptklasse:

public class ThreadStarter {

	public static void main(String[] args) {
		Worker worker;
		Thread thread;
		
		// Arbeiter anlegen.
		worker = new Worker();
		// Thread anlegen (und gleich benennen)
		thread = new Thread(worker, "Arbeiter");
		// Thread starten
		thread.start();
		try {
			// 10 Sekunden warten...
			Thread.sleep(10000);
		} catch (InterruptedException ie) {
		}
		// Thread beenden.
		thread.interrupt();
	}
}

Kommunizieren können die Threads entweder über ein gemeinsamen Objekt, Sockets oder einen PipedStream. Beim gemeinsamen Objekt musst Du daran denken, den Zugriff zu synchronisieren.
Zum Thema Socket:

• ServerSocket
• Socket

Zum Thema PipedStreams:

• PipedInputStream
• PipedOutputStream
• PipedReader
• PipedWriter

 

[micbur]

Hallo Grizzly,

danke für die umfassende Antwort.
Ich hatte das so gemacht, dass ich mir eine Klasse zum Starten schaffte (Main) und dann eine Klasse (MyThread extends Thread). Thread implementiert schon Runnable und eine run()-Methode ist auch schon da, allerdings wartet mein Main immer erst auf einen Thread, bis er zum thread2.start() kommt.

Das ist irgendwie verwirrend. Ist Nebenläufigkeit also mit Java nicht drin? Oder besser gesagt, nicht mit Threads!

Ciao micbur

 

[Roar]

doch, natürlich *lol*.
du wirst wohl irgendwas falsch gemacht haben. zeig mal deinen code.

 

[micbur]

Ich präsentiere...

public class Main {

	public static void main(String[] args) {
        
        System.out.println(" --- System is running ... generating processes ... ");
        
        ThreadGroup info4 = new ThreadGroup("Group");
        InfoThread t1 = new InfoThread(info4, "T1");
        InfoThread t2 = new InfoThread(info4, "T2");
        InfoThread t3 = new InfoThread(info4, "T3");
        InfoThread t4 = new InfoThread(info4, "T4");
        InfoThread t5 = new InfoThread(info4, "T5");
        InfoThread t6 = new InfoThread(info4, "T6");
        
        try {
            t1.start();
            t1.join();
            t3.start();
            t2.start();
            t2.join();
            t5.start();
            t3.join();
            t4.start();
            t5.join();
            t6.start();
            t6.join();
        }
        catch (Exception e) {
            System.err.println(e);
        }
        
        System.out.println(" --- System is shutting down ...");
	}
}

und dann noch ...

public class InfoThread extends Thread {
    
    
    public InfoThread(ThreadGroup group, String name) {
        this.setName(name);
    }
    
    public void run() {
        System.out.print(" +++ "+this.getName()+" ");
        Thread[] arr = new Thread[100];
        
        int numberOfThreads = enumerate(arr);
//        System.out.println(numberOfThreads+"|"+arr.length);
        
        System.out.print("(");
        for (int i = 0; i < numberOfThreads; i++) {
            if (arr[i].isAlive()) {
                System.out.print(arr[i].getName()+",");
            }
        }
        System.out.print(")\r\n");
        
        try {
            
            sleep(1000);
            
        }
        catch (Exception e) {
            System.err.println(e);
        }
        
        System.out.print(" --- "+this.getName()+" ");
        System.out.print("(");
        for (int i = 0; i < numberOfThreads; i++) {
            if (arr[i].isAlive()) {
                System.out.print(arr[i].getName()+",");
            }
        }
        System.out.print(")\r\n");
    }
}

Ciao micbur

 

[Beni]

join wartet bis der Thread abgeschaltet wurde...

Also versuch es einfach mit einer anderen Reihenfolge!

        try {
            t1.start();
            t3.start();
            t2.start();
            t5.start();
            t4.start();
            t6.start();

            t1.join();
            t2.join();
            t3.join();
            t4.join();
            t5.join();
            t6.join();
        }
        catch (Exception e) {
            System.err.println(e);
        }

mfg Beni

 

[Guest]

Hmmm, eine Reihenfolge hat wenig damit zu tun, denke ich.

OK, nehmen wir an, ich erzeuge 6 (wirklich) nebenläufige Prozesse, die eine Sekunde warten, und sich dann beenden, dann dauert der gesamte Programmabluaf eine Sekunde, weil jeder Prozess für sich eine Sekunde wartet.

Jedoch dauert der gesamte Programmablauf bei mir 6 Sekunden, es werden also alle Prozesse sequenziell angestoßen und durchlaufen. Das ist aber nicht nebenläufig.

Oder sehe ich das falsch?

Ciao micbur

 

[Beni]

Dann pass mal auf:

Variante 1:

public class Main{
    public static void main( String[] args ){
        ThreadTest a = new ThreadTest( "A" );
        ThreadTest b = new ThreadTest( "B" );
        ThreadTest c = new ThreadTest( "C" );
        ThreadTest d = new ThreadTest( "D" );
        ThreadTest e = new ThreadTest( "E" );
        
        long begin = System.currentTimeMillis();
        
        try {
            a.start();
            b.start();
            c.start();
            d.start();
            e.start();
            
            a.join();
            b.join();
            c.join();
            d.join();
            e.join();
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        
        long end = System.currentTimeMillis();
        
        System.out.println();
        System.out.println( "Laufzeit: " + (end - begin) / 1000 + "s" );
    }
}

class ThreadTest extends Thread{
    private String name;
    
    public ThreadTest( String name ){
        this.name = name;
    }
    
    public void run(){
        for( int i = 0; i < 5; i++ ){
            System.out.println( name + ": " + i );
            
            try {
                Thread.sleep( 1500 );
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Ausgabe:
A: 0
B: 0
C: 0
D: 0
E: 0
A: 1
B: 1
D: 1
C: 1
E: 1
A: 2
B: 2
D: 2
C: 2
E: 2
A: 3
B: 3
C: 3
D: 3
E: 3
A: 4
B: 4
C: 4
D: 4
E: 4

Laufzeit: 7s

Variante 2:

public class Main{
    public static void main( String[] args ){
        ThreadTest a = new ThreadTest( "A" );
        ThreadTest b = new ThreadTest( "B" );
        ThreadTest c = new ThreadTest( "C" );
        ThreadTest d = new ThreadTest( "D" );
        ThreadTest e = new ThreadTest( "E" );
        
        long begin = System.currentTimeMillis();
        
        try {
            a.start();
            a.join();
            
            b.start();
            b.join();
            
            c.start();
            c.join();
            
            d.start();
            d.join();
            
            e.start();
            e.join();
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        
        long end = System.currentTimeMillis();
        
        System.out.println();
        System.out.println( "Laufzeit: " + (end - begin) / 1000 + "s" );
    }
}

class ThreadTest extends Thread{
    private String name;
    
    public ThreadTest( String name ){
        this.name = name;
    }
    
    public void run(){
        for( int i = 0; i < 5; i++ ){
            System.out.println( name + ": " + i );
            

            try {
                Thread.sleep( 1500 );
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Ausgabe:
A: 0
A: 1
A: 2
A: 3
A: 4
B: 0
B: 1
B: 2
B: 3
B: 4
C: 0
C: 1
C: 2
C: 3
C: 4
D: 0
D: 1
D: 2
D: 3
D: 4
E: 0
E: 1
E: 2
E: 3
E: 4

Laufzeit: 37s


Achte auch auf die Reihenfolge der Ausgabe... Die Laufzeit...

Beweisführung abgeschlossen. :wink:

mfg Beni