Fragen zum Thread-Thema

[tanechka]

Hallo,

ich habe fragen zur Console-Ausgabe. Ich habe folgendes Programm:

public class XMapp implements Runnable{

	  static String s="ABC";

	  public void run(){
	    synchronized(this){
	      System.out.print(s);
	    }
	  }

	  public static void main(String args[])throws Exception{
	    Thread td=new Thread(new XMapp());
	    synchronized(td){
	      td.start();
	      //Thread.sleep(1000);
	      s="XYZ";
	    }
	  }

	}

Wenn ich die Zeile Thread.sleep(1000);also main-Thread schlafe für eine Sekunde auskommentiere, habe ich die Ausgabe "XYZ", sonst "ABC". Wie soll man das verstehen? Die Zeile mit td.start() ist doch davor und Thread td sollte den alten Wert "ABC" ausgeben müssen?

 

[Phash]

der Thread geht in den Hintergrund

wenn er nicht schläft, dann ist er schnell genug, um vor dem system.out wieder da zu sein, und die Variable ist schon umgesetzt
wenn er schläft, ist system.out schneller und die Variable noch nicht gesetzt


Teste das ganze mal, indem du dir s an verschiedenen Stellen ausgeben lässt - einmal vor dem Thread aufruf, einmal vor dem Schlafen und einmal nach dem Schlafen (markiere die Ausgabestellen aber)

dann wirst du es merken

 

[kaoZ]

Du startest den Thread, dieser führt nach dem aufruf von start() sein runnable aus, und wird dann schlafen gelegt, heißt , erst wird "ABC" ausgegeben, dann wird der Thread schlafen geschickt, dann wird der Referenz ein neues String Objekt zugewiesen, usw. usw.

wenn du nun das auskommentierst, wird der Referenz direkt ein neues Objekt zugewiesen und demnach auch gleich "XYZ"
ausgegeben bevor die Ausgabe erfolgt, da dies anscheinend schneller passiert , als die ausgabe über den printStream.

 

[Phash]

package de.mr.krams;

public class XMapp implements Runnable {

    static String s = "ABC";

    @Override
    public void run() {
	System.out.println("1+" + s);
	synchronized (this) {
	    System.out.println("2+" + s);
	}
	System.out.println("3+" + s);
    }

    public static void main(String args[]) throws Exception {
	System.out.println("4+" + s);
	Thread td = new Thread(new XMapp());
	synchronized (td) {
	    td.start();
	    System.out.println("5+" + s);
	    Thread.sleep(1000);
	    s = "XYZ";
	    System.out.println("6+" + s);
	}
    }

}

hier kannst du es auf der Konsole schön verfolgen

 

[Network]

Deine synchronized sind aber auch ganz schön wahllos mal im Code verteilt worden, kann das sein?
Aber huer kommst du auf ein interessantes Thema zu sprechen und zwar Multithreading. Du kannst nie vorhersagen was zuerst passieren wird oder in welcher Reihenfolge. Daran solltest du dich gewöhnen wenn du Multithreading anwenden willst (so wie es scheint), denn genau das ist die gesammte Problematik hinter Multicore und warum viele Spiele z.B. nie alle Kerne nutzen.

In deinem Fall kann ich nicht sagen an was es liegt.
Meine erste Vermutung wäre das du mal versuchen solltest "synchronized (td)" zu entfernen. Das blockt eventuell den neu erstellten Thread td, weshalb sich Thread.sleep (1000) auch darauf auswirken könnte.
Entferne das mal (ist vollkommen unnötig) und schaue was passiert.

 

[tanechka]

ich habe so verstanden Thread.sleep(1000);- ist hier main-Thread gemeint? Liege ich falsch?
Wenn ich Phash dein Programm ausführe kriege ich folgende Ausgabe:
4+ABC
5+ABC
1+ABC
2+ABC
3+ABC
6+XYZ

beim run() hat man immer noch altes Wert. Ich würde bei meinem Programm auch altes Wert erwarten.

 

[kaoZ]

Andere Frage , warum erstellst du nicht innerhalb deines Objektes den Thread der dann sein Runnable ausführt ?

Das hier wäre ein Vorschlag, außer es ging dir nur darum warum es so ist, ebenso könntest du natürlich auch gleich die "Wartezeit", im Konstruktor übergeben, wie gesagt ist nur ein Vorschlag :

public class ThreadExample implements Runnable{

	private String s = "ABC";
	
	public ThreadExample(){
		Thread t = new Thread(this);
		t.start();
	}
	
	public ThreadExample(String s){
		Thread t = new Thread(this);
		this.s = s;
		t.start();
	}
	
	
	@Override
	public void run(){
		System.out.println(s);
		
		try {
			Thread.sleep(1000);
		}
		catch (Exception ex) {
			ex.printStackTrace();
		}
	}
	
	public static void main(String[] args){
		new ThreadExample("XYZ");
		new ThreadExample();
	}

}

insofern dein Runnable nicht in einer Schleife ausgeführt wird kannst du nach dem Thread.sleep der Variable so oft du willst ein neues Literal zuweisen, hat aber keinen Effekt , da das Runnable , in deinem Fall das ausgeben des String literals bereits passiert ist nachdem du den Thread gestartet hast und ihn danach erst schlafen schickst, wenn du das Thread.sleep auskommentierst, wird das Runnable ausgeführt, deiner variable direkt das neue literal zugewiesen und erst dann geprintet, das liegt hier wie bereits schon erwähnt daran das du keinen Einfluss darauf hast, wie und wann der Thread sein Runnable ausführt und du mit .start() lediglich das flag setzt, ebenso ähnlich ist es beim Beenden eines Threads mit .interrupt() , außer wenn du den Thread mitten in seiner Ausführung komplett abwürgst.

 

[tanechka]

mir geht es darum, wieso es so ist. Auch wenn ich dein run() als synchronized definiere. Wechselt sich die Ausgabe: mal
XYZ
ABC

mal:

ABC
XYZ

obwohl die Reihenfolge im main() definiert ist:
new ThreadExample("XYZ");
new ThreadExample();

 

[kaoZ]

Das liegt , wie oben schon mehrfach erwähnt wurde daran, das du keinen Einfluss darauf hast , wann der Thread gestartet, bzw. welcher Thread sein Runnable zuerst ausführt, und noch von unzähligen anderen Faktoren.

ansonsten versuch doch mal run() direkt aufzurufen, und nicht start(), beim Aufruf von run() wird sequentiell nacheinander ausgeführt, beim Aufruf von start() , wie bei Threads gewünscht Parallel.

Hier z.B sollte die Ausgabe immer A B sein da hier Sequentiell ausgeführt wird, also erst das runnable der klasse ThreadA dann das der Klasse ThreadB

public class Bar{

	class ThreadA implements Runnable{

		
		public ThreadA(){
			new Thread(this).run();
		}
		
		@Override
		public void run(){
			
			System.out.println("A");
		}
		
	}
	
	class ThreadB implements Runnable{

		
		public ThreadB(){
			new Thread(this).run();
		}
		
		@Override
		public void run(){
			
			System.out.println("B");
		}
		
	}
	
	public static void main(String[] args){
		new Bar().new ThreadA();
		new Bar().new ThreadB();
	}
}

 

[tanechka]

vielen Dank für die Hilfe, jetzt verstehe ich.