[bLaCkRaBbIt]

hi leute,

ich bin grad in vorbereitung auf eine rechnerarchitekturklausur und hab da eine übung gefunden, die man mit java lösen soll. meine java zeiten sind schon eine ganze weile her und wir haben da auch nie über threads gesprochen. wir müssen auch groß kein java können für die klausur, ist ja schließlich keine programmierklausur. aber die lösung würde mich trotzdem interessieren.

aufgabe: erstellen sie ein java-programm, das zwei threads produziert, die jeweils die zahlen 0 bis 100 ausgeben und dazu einen string, der kennzeichnet von welchem thread die zahl stammt.


ich hab ein wenig recherchiert und meiner meinung nacht müsste das so aussehen:

import static Prog1Tools.IOTools.*; //klassen für die ausgabe
public class DemoThread extends Thread {

  
	public void run(String threadName) {
	  System.out.print("Thread " + threadName);
	  for(int i = 0; i < 101; i++) {
		 try {
		   system.out.print(" " + i);
		 }
		 catch(InterruptedException e) {
		   system.out.println("fehler bei thread " + threadName + " bei zahl " + i);
		 }
	  }
	}

	 public static void main(String[] args) {
	   run("1");
	   System.out.println();
	   run("2");
	 }
  }

stimmt das so?

Dieser Beitrag wurde von mo bearbeitet: 15. November 2006 - 23:47

[Rika]

Nicht nur, daß das gar keinen neuen Thread produziert (!), die Zuordnung von Ausgabe zu Thread is auch nicht eindeutig (z.B.: Thread 1, Thread 2, 1, 1). Außerdem nimmt man lieber Runnable statt Thread zu extenden. Und warum catchst du die InterruptedException, die dort gar nicht auftreten kann?

import static System.out;

public class FooBar {

	class DemoThread implements Runnable {
	
		private int nr;

		DemoThread(int nr) {
			this.nr = nr;
		}

		public void run() {
			for(int i = 0; i < 101; i++) 
				out.println("Thread #"+nr+": "+i);
		}
	}

	public static void main(String[] args) {
		new Thread(new DemoThread(1)).start();
		new Thread(new DemoThread(2)).start();
	}
}

[bLaCkRaBbIt]

warum nimmt man lieber runnable? ich habe noch ne lösung mit einem konstruktor...

public class DemoThread extends Thread {
   private String threadName;

   public DemoThread(String name) {
	  threadName = name;
   }
	public void run() {
	  for(int i = 0; i < 101; i++) {
		 system.out.println(this.threadName + " " + i);
		 try {
		   Thread.sleep(100);
		 }
		 catch(InterruptedException e) {
		   system.out.println("Thread " + this.threadName + " wurde unterbrochen bei zahl " + i);
		 }
	  }
	}

	 public static void main(String[] args) {
	   new DemoThread("1").start();
	   new DemoThread("2").start();
	 }
  }

Dieser Beitrag wurde von bLaCkRaBbIt bearbeitet: 13. November 2006 - 19:31

[Schaik]

Hi!

Ich habe das so gemacht:

package threads;

public class Threads{
	
	public static void main( String[] args ){
	 	Thread t1 = new Thread(new Counter(), "Counter 1: ");
	 	Thread t2 = new Thread(new Counter(), "Counter 2: ");
	 	t1.start();
	 	t2.start();
	 	//oder auch:
	 	//new Thread(new Counter(), "Counter 1: ").start();
	 	//new Thread(new Counter(), "Counter 2: ").start();
	 }
}

class Counter implements Runnable
  {
	public void run()
	{
	for ( int i = 0; i < 500; i++ )
	  System.out.println(Thread.currentThread().getName()+i);
  }
}

Man kann es natürlich auch anderst machen zb. das er sich von alleine startet dazu ändert man die Klasse Counter wie folgt:

class Counter implements Runnable
  {
	  Counter(String name){
		  new Thread(this, name).start();
	  }
	public void run()
	{
	for ( int i = 0; i < 500; i++ )
	  System.out.println(Thread.currentThread().getName()+i);
  }
}

Und beim Aufruf den Namen z.B. als String mitgeben:

Thread t1 = new Thread(new Counter("Counter 1: "));

Bei weiteren Interesse empfehle ich dir das Ebook: "Java ist auch eine Insel" auf Galileocomputing da ist es echt spitze erklärt!

[Witi]

@Schaik
Ist eigentlich genau das gleiche was Rika gezeigt hat.
Nur dass Rika statische Klassen und statische Imports benutzt. Dort sind zwar ein, zwei kleinere Fehler, aber sonst viel schöner, kürzer und übersichtlicher.

[Rika]

Zitat

warum nimmt man lieber runnable?

Weil leichtgewichtiger und bessere Trennung von Thread und Threading-Kontrolle.

@Schaik: Letzteres wird nicht funktionieren, weil 'this' innerhalb des Konstrukturs noch 'null' ist - das Objekt ist ja erst am Ende des Konstruktors erzeugt.

@Witi: Was soll da nicht stimmen? Übrigens entspricht es vor allem den Java Programming Guidelines.

[Schaik]

Zitat (Rika: 14.11.2006, 13:29)

@Schaik: Letzteres wird nicht funktionieren, weil 'this' innerhalb des Konstrukturs noch 'null' ist - das Objekt ist ja erst am Ende des Konstruktors erzeugt.

Wenn ich es so mache funktioniert es wunderbar.

Zitat (Witi: 14.11.2006, 12:44)

Ist eigentlich genau das gleiche was Rika gezeigt hat.
Nur dass Rika statische Klassen und statische Imports benutzt. Dort sind zwar ein, zwei kleinere Fehler, aber sonst viel schöner, kürzer und übersichtlicher.

Tschuldigung wusste nicht das man seine Lösungswege nicht posten darf wenn bereits ein, wie du schon sagst, anderer vorhanden ist. Sry für die ausdrucks weiße....

[Witi]

Zitat

Tschuldigung wusste nicht das man seine Lösungswege nicht posten darf wenn bereits ein, wie du schon sagst, anderer vorhanden ist. Sry für die ausdrucks weiße....

Hey...war doch nicht böse gemeint.
War nur eine Anmerkung

Zitat

Was soll da nicht stimmen?

(Bezogen auf Java 1.5)
Vielleicht liegt es auch an mir, aber ich muss die Klasse DemoThread als statisch deklarieren sonst meckert der Compiler beim Aufruf in der main.

[Rika]

Static wäre aber total falsch. Eventuell mal (new Thread(new DemoThread(1))).start(); klammern?

[Witi]

mach ichs mal was ausführlicher...

javac FooBar.java
FooBar.java:1: cannot find symbol
symbol: class System
import static System.out;
			  ^
FooBar.java:1: static import only from classes and interfaces
import static System.out;
^
FooBar.java:15: cannot find symbol
symbol  : variable out
location: class FooBar.DemoThread
				out.println("Thread #"+nr+": "+i);
				^
FooBar.java:20: non-static variable this cannot be referenced from a static context
		new Thread(new DemoThread(1)).start();
				   ^
FooBar.java:21: non-static variable this cannot be referenced from a static context
		new Thread(new DemoThread(2)).start();
				   ^
5 errors

Warum der java.lang nicht kennt, wundert mich...Aber seis drum, dann halt ein "import java.lang.System.out"

Danach folgen immer noch diese beiden Fehler:

javac FooBar.java
FooBar.java:20: non-static variable this cannot be referenced from a static context
		(new Thread(new DemoThread(1))).start();
					^
FooBar.java:21: non-static variable this cannot be referenced from a static context
		(new Thread(new DemoThread(1))).start();
					^
2 errors

Nur, wenn ich DemoThread als statisch (also "static class DemoThread implements Runnable") deklariere funktioniert es. Ist IMO aber auch logisch, da man aus der statischen Methode main nicht auf die statische Klasse DemoThread zugreifen kann, ohne dass sie extra so benannt ist.

[Rika]

Och menno, soll natürlich "import static System.out.println" heißen. Dann klappt's auch ohne java.lang.

Und das mit dem static ist natürlich auch Unsinn. Das Problem ist das "this.blah=blah"-Mantra. Mach einfach mal

DemoThread(int _nr) {
			nr = _nr;
		}

.

Statisch ist aber auch jeden Fall falsch, sonst wären die beiden Instanzen von DemoThread identisch.

Also, nochmal ganz sauber:

import static System.out.println;

public final class FooBar {

	final class DemoThread implements Runnable {
	
		private final String threadname;

		DemoThread(final int nr) {
			threadname = "Thread #" + nr + ": ";
		}

		public void run() {
			for(int i = 0; i < 101; i++)
				out.println(threadname + i);
		}
	}

	public static void main(final String[] args) {
		Thread thread1 = new Thread(new DemoThread(1));
		Thread thread2 = new Thread(new DemoThread(2));
		thread1.start();
		thread2.start();
	}
}

[Witi]

weiter gehts

FooBar.java:1: package System does not exist
import static System.out.println;
					^
FooBar.java:1: static import only from classes and interfaces
import static System.out.println;
^
FooBar.java:15: cannot find symbol
symbol  : variable out
location: class FooBar.DemoThread
				out.println(threadname + i);
				^
FooBar.java:20: non-static variable this cannot be referenced from a static context
		Thread thread1 = new Thread(new DemoThread(1));
									^
FooBar.java:21: non-static variable this cannot be referenced from a static context
		Thread thread2 = new Thread(new DemoThread(2));
									^
5 errors

Zitat

Statisch ist aber auch jeden Fall falsch, sonst wären die beiden Instanzen von DemoThread identisch.

huh?
DemoThread wird innerhalb der Klasse FooBar deklariert, also eine verschachtelte Klasse bzw. "nested class".

Du willst aber von einer statischen Methode aus auf diese zugreifen und somit musst du sie als statisch deklarieren sonst kommst du nicht dran.

Und das sind _keine_ identischen Instanzen, da du mit "new" zwei unterschiedliche Objekte erzeugst.

Der folgende Code funktioniert bspw. bei mir

import static java.lang.System.out;

public final class FooBar {

	static final class DemoThread implements Runnable {
	
		private final String threadname;

		DemoThread(final int nr) {
			threadname = "Thread #" + nr + ": ";
		}

		public void run() {
			for(int i = 0; i < 101; i++)
				out.println(threadname + i + " " + this);
		}
	}

	public static void main(final String[] args) {
		Thread thread1 = new Thread(new DemoThread(1));
		Thread thread2 = new Thread(new DemoThread(2));
		thread1.start();
		thread2.start();
	}
}

[Rika]

Die beiden Objekte teilen sich aber den String threadname, d.h. bei der erste Thread nennt sich dann auch plötzlich Thread 2. Und natürlich kann man von statischen Methoden aus nicht-statische Klassen instanzieren.

Aber die Threads, die sollte man als static deklarieren.

import static java.lang.System.out;

public final class FooBar {

	private final static Thread thread1 = new Thread(new DemoThread(1));
	private final static Thread thread2 = new Thread(new DemoThread(2));
	
	final class DemoThread implements Runnable {
	
		private final String threadname;

		DemoThread(final int nr) {
			threadname = "Thread #" + nr + ": ";
		}

		public void run() {
			for(int i = 0; i < 101; i++)
				out.println(threadname + i + " " + this);
		}
	}

	public static void main(final String[] args) {
		thread1.start();
		thread2.start();
	}
}

So, und das klappt aber.

[Witi]

bei mir leider immer noch nicht...

FooBar.java:5: non-static variable this cannot be referenced from a static context
	private final static Thread thread1 = new Thread(new DemoThread(1));
													 ^
FooBar.java:6: non-static variable this cannot be referenced from a static context
	private final static Thread thread2 = new Thread(new DemoThread(2));
													 ^
2 errors

Zitat

Die beiden Objekte teilen sich aber den String threadname

Natürlich teilen sie sich, aber wenn du, wie ich es gemacht habe, this ausgibst wirst du sehen, dass es zwei verschiedene Objekte sind.

[Rika]

private final static Runnable demothread1=new DemoThread(1);
private final static Thread thread1 = new Thread(demothread1);