✔ WaitForSingleObject

[Klobow]

Hallo zusammen,

gibt es sowas in (oder sowas Ähnliches in Java?)

Kurz zum Problem:
Ich habe zwei Threads A und B. Thread A soll nun an einer best. stelle auf B warten im Moment habe ich das mit einem Flag in etwa so gelöst:

A:

...
while(shareSrc.getFlag() == false){
   Thread.Sleep(200);
}
...

Die while Schleife bricht natürlich nach einer definierten max. Zeit ab und auch getFlag und setFlag für die gmeinesamme Resource von A und B sind mittels synchronized geschützt. Es funktioniert soweit auch ganz gut.

In C++ unter Windows hätte ich das ganze mittels eine WaitForSingleObject gelöst, leider habe ich etwas ähnliches in Java bislang nicht gefunden. Gibt es soetwas?

Danke für eure Antworten
gruß Tobias

 

[Thomas Darimont]

Hallo,

Ich habe zwei Threads A und B. Thread A soll nun an einer best. stelle auf B warten im Moment habe ich das mit einem Flag in etwa so gelöst:

Möchtest du in Thread A auf das Ende von Thread B warten ? Das wäre über threadB.join() in ThreadA run(...) möglich.

Oder willst du warten bis Thread B eine Art Signal gibt um eine bestimmte Bedingung zu signalisieren?

Schau mal hier:

package de.tutorials;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadingExample {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		joinExample();
		conditionExample();
	}

	private static void conditionExample() {
		System.out.println("conditionExample");
		final Lock lock = new ReentrantLock();
		final Condition cond = lock.newCondition();

		final Thread tB = new Thread() {
			public void run() {
				System.out.println("Start tb");
				try {
					TimeUnit.SECONDS.sleep(3);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}

				try {
					lock.lock();
					cond.signal();
				} finally {
					lock.unlock();
				}

				System.out.println("End tb");
			}
		};

		final Thread tA = new Thread() {
			public void run() {
				System.out.println("Start ta");
				
				try {
					lock.lock();
					try {
						cond.await();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				} finally {
					lock.unlock();
				}

				
				System.out.println("End ta");
			}
		};

		tA.start();
		tB.start();
	}

	private static void joinExample() {
		System.out.println("joinExample");

		final Thread tB = new Thread() {
			public void run() {
				System.out.println("Start tb");
				try {
					TimeUnit.SECONDS.sleep(3);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println("End tb");
			}
		};

		final Thread tA = new Thread() {
			public void run() {
				System.out.println("Start ta");
				try {
					tB.join();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println("End ta");
			}
		};

		tA.start();
		tB.start();
		
		try {
			tA.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}

Gruß Tom

 

[Klobow]

Genau das mit der Condition!

Vielen Dank für die schnelle und ausführliche Antwort!
gruß Tobias

 

[Klobow]

Ok, das Problem ist gelöst, aber ich habe da noch ein kleines Verständnissproblem.
Leider hat mir JavaDOC auch nicht weiter geholften.

Wenn A locked um auf Cond zu warten.
Wie kann dann B auch locken um Cond zu setzten!?

Ist das nicht gerade der Sinn das lock den Zugriff für andere Threads sperrt und sollte dann nicht (wenn A mit await früher dran ist) ein Deadlock auftreten? Wo liegt das geheimniss?

Schöne Grüße
Tobias

 

[Thomas Darimont]

Hallo,

schau dir mal an was bei der await() Methode steht.
http://java.sun.com/javase/6/docs/api/java/util/concurrent/locks/Condition.html#await()

Gruß Tom

 

[Klobow]

All clear,
vielen Dank!

gruß Tobias