Threads

Wie kann man 3 Threads Objekte erzeugen, damit sie sich untereinander synchronisieren wie z.B
in der run() Methode müssen Threads ihren Namen ausgeben.

Thread-0
Thread-1
Thread-2
Thread-0
Thread-1
Thread-2
Thread-0
Thread-1
Thread-2

usw.
Ich hab viel Mühe gegeben, aber klappt es leider nicht, ich wäre dankbar für jede Hilfe

https://wiki.byte-welt.net/wiki/Java_und_die_Synchronisation

Hier eine Übersicht zu threads.

Du solltest dein Quellcode Zeigen, damit man nicht so abstrakt sprechen muss.

    public class NameOutput extends Thread {


	@Override
	public void run() {

	
		
		while(true) {
			try {
					Thread.sleep(1000);
					synchronized(getClass()) {
				System.out.println(getName() + ": ");	
				
}
				}catch(InterruptedException e) {
					
				}
				
				
			
		}
		} 
	

	public static void main(String[] args) {
		Thread t = new Thread();
		Thread t1 = new Thread();
		Thread t2 = new Thread();

		t.start();
		t1.start();
		t2.start();

		try {
			t.join();
			t1.join();
			t2.join();
		} catch (InterruptedException e) {

		}
	}

}

aber funktioniert nicht, wie gewollt

Was wäre denn wie gewollt? Das die Ausgaben in der selben Reihenfolge sind? Das wird nicht passieren. Threads laufen asynchron und die werden werden immer unterschiedlich laufen. Ansonsten bräuchtest du keine Threads.

Wenn du das Ergebnis sortiert haben möchtest, dann musst du mit Tasks und Futures arbeiten. Dann kannst du das Ergebnis vor der Ausgabe bearbeiten

public class ThreadsTest {
	public static void main(String[] args) throws InterruptedException {
		Thread[] threads = { new Thread(new Runnable() {
			@Override
			public void run() {
				for (int i = 0; i < 60; i++) {
					System.out.println(i + " " + this.toString());
					try {
						Thread.sleep(1);
					} catch (InterruptedException ie) {
						ie.printStackTrace();
					}
				}
			}
		}), new Thread(new Runnable() {
			@Override
			public void run() {
				for (int i = 0; i < 60; i++) {
					System.out.println(i + " " + this.toString());
					try {
						Thread.sleep(1);
					} catch (InterruptedException ie) {
						ie.printStackTrace();
					}
				}
			}
		}), new Thread(new Runnable() {
			@Override
			public void run() {
				for (int i = 0; i < 60; i++) {
					System.out.println(i + " " + this.toString());
					try {
						Thread.sleep(1);
					} catch (InterruptedException ie) {
						ie.printStackTrace();
					}
				}
			}
		}) };
		for (Thread thread : threads) {
			thread.start();
		}
		for (Thread thread2 : threads) {
			thread2.join();
		}
	}
}

Thread.sleep(1); kann den Reihenfolgewechsel der Threads begünstigen.
Eine Ausgabe könnte dann sein:

...
12 ThreadsTest$2@54f50172
12 ThreadsTest$1@4fe570b5
13 ThreadsTest$2@54f50172
12 ThreadsTest$3@3edac053
14 ThreadsTest$2@54f50172
13 ThreadsTest$1@4fe570b5
13 ThreadsTest$3@3edac053
14 ThreadsTest$3@3edac053
14 ThreadsTest$1@4fe570b5
...
1 Like

Wieder so eine „Hier ist die Aufgabenstellung, postet mal die Lösung“-Frage :roll_eyes:

Mehr input!

Geht es darum, dass die Ausgabe immer in der Reihenfolge 1-2-3 stattfinden soll?

Ehrlich, bin ich nach nochmaligem Lesen auch etwas überfragt… Möchtest du, dass die Threads ihre Nummern in geordneter Reihenfolge nach ausgeben - oder soll die Reihenfolge gemischt sein? Ersteres wäre synchron oder synchronisiert, und Zweiteres wäre asynchron oder nicht synchronisiert bzw. parallel bzw. nebenläufig. Zur Synchronisierung gibt es unterschiedliche Techniken - aber zunächst müsste man wissen, was das Ziel sei.

Btw. Du kannst hier Quelltext formatiert mit Java-„Tags“ einfügen. Dann können alle das viel leichter lesen.

1 Like