Threads nacheinander ablaufen lassen, da sonst...

[saberdam]

Hallo,

Ich weiß, hier gibt es 1000 Themen zu Threads, aber ich habe ein Verständnisproblem, glaube ich zu mindest.

Ich hab ein Programm, in dem zwei verschiedene Threads laufen. Wenn ich die Threads unabhängig laufen lasse, ist das ganze kein Problem. Nur in Thread 1 , wird weniger Rechenaufwand betrieben, in Thread 2 dagegen sehr viel durch Listen gegangen. Ich möchte, dass Thread 1 immer wartet bis Thread 2 fertig ist.

Aber erst mal zu meinem Ansatz, ich verstehe hier schon nicht, warum diese Threads sich nicht ablösen und nacheinander ablaufen?!

public class CopyOfThreadMit implements Runnable
{

	public synchronized void thread1Ausgabe()
	{
		
		try
		{
			this.wait();
		}
			catch(InterruptedException e)
			{
			
			}
		System.out.println("Thread 2 am Start!");
		this.notifyAll();
	}
	
	public void run() 
	{
		while(true)
		{	
					
			thread1Ausgabe();
			
		}
	}

}

public class ThreadMitWaitUndSo implements Runnable
{
	
	
	
	public synchronized void thread1Ausgabe()
	{	
		try
		{
			this.wait();
		}
			catch(InterruptedException e)
			{
			
			}
		System.out.println("Thread 1 am Start!");
		this.notifyAll();
	}
	
	public void run() 
	{
		while(true)
		{	
			
			thread1Ausgabe();
			
		}
	}

}

Die Threads werden dann in einer MainKlasse gestartet.
Kann mir jemand sagen, warum dort nichts passiert?
Danke im vorraus schon mal!

 

[Noctarius]

Du kannst mit Semaphoren arbeiten wenn du einen bestimmten Satz Threads starten und die Anderen warten lassen willst.

 

[saberdam]

Ich werd das ausprobieren.
Danke.
Aber ich will wait() und sowas auch verstehen, kann mir jemand anhand des beispiels erklären, warum das nicht funktioniert?

 

[Marco13]

Da stehen wait()s die auf den Objekten selbst arbeiten, und von notifyAll() sehe ich da nichts... Wenn dann müßten beide Threads ein gemeinsames Objekt haben, auf dem sie sich mit gemeinsamesObjekt.wait() und gemeinsamesObjekt.notifyAll() synchronisieren können...

 

[saberdam]

Hm,

Ich hab versucht, in einer Klasse ein Objekt zu erstellen und es anhand der getter und setter Methoden, in der anderen Klasse zu benutzen, aber dann sagt er mir java.lang.IllegalMonitorStateException.
Wie kann ich den beiden ein Objekt geben?
Hier nochmal meine Veränderung:

public class ThreadMitWaitUndSo implements Runnable
{
	
	Object o = new Object();
	
	public synchronized void thread1Ausgabe()
	{	
		Object f = getO();
		try
		{
			f.wait();
			setO(f);
		}
			catch(InterruptedException e)
			{
			
			}
		System.out.println("Thread 1 am Start!");
		f.notifyAll();
		setO(f);
	}
	
	

	public void run() 
	{
		while(true)
		{	
			
			thread1Ausgabe();
			
		}
	}

	public Object getO() {
		return o;
	}

	public void setO(Object o) {
		this.o = o;
	}

}
[/Java]

und die andere Klasse
[Java]

public class CopyOfThreadMit implements Runnable
{
	ThreadMitWaitUndSo neuesObjekt = new ThreadMitWaitUndSo();
	
	public synchronized void thread1Ausgabe()
	{
		Object f = neuesObjekt.getO();
		try
		{
			
			f.wait();
			neuesObjekt.setO(f);
		}
			catch(InterruptedException e)
			{
			
			}
		System.out.println("Thread 2 am Start!");
		f.notifyAll();
		neuesObjekt.setO(f);
	}
	
	public void run() 
	{
		while(true)
		{	
				thread1Ausgabe();
			
		}
	}

}
[/Java]

 

[javimka]

vor allen wait() und notifyAll() musst du das Objekt synchronisieren. Richtig sieht das dann so aus:

synchronized(f) {
  f.wat(); // oder notifyAll()
}

 

[saberdam]

Hallo,

Ich hab deinen Ansatz versucht, aber die Threads geben komischerweise nichts aus, also gehe ich davon aus, dass sie nicht nacheinander ausgeführt werden?!

Ich hab die Klassen so verändert!

public class ThreadMitWaitUndSo implements Runnable
{
	
	Object o = new Object();
	
	public void thread1Ausgabe()
	{	
		Object f = getO();
		
		synchronized (f) 
		{
			try 
			{
				f.wait();
			} 
			catch (InterruptedException e) 
			{
				e.printStackTrace();
			}
		
			
		System.out.println("Thread 1 am Start!");
		f.notifyAll();
		}
	}
	
	

	public void run() 
	{
		while(true)
		{	
			
			thread1Ausgabe();
			
		}
	}

	public Object getO() {
		return o;
	}

	public void setO(Object o) {
		this.o = o;
	}

}

public class CopyOfThreadMit implements Runnable
{
	ThreadMitWaitUndSo neuesObjekt = new ThreadMitWaitUndSo();
	
	public void thread1Ausgabe()
	{
		Object f = neuesObjekt.getO();
		
		synchronized (f) 
		{
			
		
		     try 
		    {
			f.wait();
			
		    } 
		             catch (InterruptedException e) 
		            {
			         e.printStackTrace();
		            }
		
		System.out.println("Thread 2 am Start!");
		
		f.notifyAll();
		
		}
		
	}
	
	public void run() 
	{
		while(true)
		{	
				thread1Ausgabe();
			
		}
	}

}

 

[SlaterB]

die Klassen werden nie gestartet, da fehlt die main, was macht diese?

und was sollen die beiden Threads machen? wenn beide nur warten, dann warten sie doch in alle Ewigkeit, wer weckt sie wieder auf?

CopyOfThreadMit erstellt sich ein neues ThreadMitWaitUndSo-Objekt, das ist nicht das aus der main, oder?
das wird gar nicht als Thread gestartet, hat dies einen Sinn?

 

[saberdam]

Ah, ich hätts nochmal sagen sollen. In meinem ersten Eintrag hatte ich geschrieben, dass es eine MainKlasse gibt, die zwei Threads startet, also :

Die Threads werden dann in einer MainKlasse gestartet.

DIe Threads sollen einfach was ausgeben, also das was in den beiden Methoden steht

System.out.println("Thread 1 am Start!");

oder halt

System.out.println("Thread 2 am Start!");

Ich dachte mit dem f.notifyAll geb ich das Signal, dass der wartende Thread starten kann?
Muss ich dieses GemeinsameObjekt in der Mainklasse deklarieren?


Das hier ist die MainKlasse:

import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;


public class Main {

	
	public static void main(String[] args) throws InterruptedException 
	{
                Thread t1 = new Thread (new ThreadMitWaitUndSo());
		Thread t2 = new Thread (new CopyOfThreadMit());	
	
		t1.start();
		t2.start();
	}
}

 

[SlaterB]

jeder Thread ruft erst wait() auf und danach notifyAll(),
so funktioniert das doch nicht, das wäre so als wenn sich zwei Menschen jeweils vor ihr Telefon setzen und erst rangehen, wenns bei ihnen klingelt..

> Muss ich dieses GemeinsameObjekt in der Mainklasse deklarieren?

das wäre auch sehr hilfreich