Threads Probleme mit verschachtelten Synchronized blöcken

[napstar]

Hey..

bin neu hier im Forum.. habe direkt ne frage ..

ich bin Informatik Student und schreibe morgen die Softwareentwicklung 2 Klausur..
hab hier mal ne ehemalige Prüfung an der ich letztes Semester gescheitert bin

public class Locker implements Runnable {
	
	private final String name;
	private final Integer monitor1;
	private final Integer monitor2;
	private final Integer monitor3;
	static long startTime = System.currentTimeMillis();
	
	public Locker(String name, Integer monitor1, Integer monitor2 , Integer monitor3) {
		this.name = name;			//A		//B
		this.monitor1 = monitor1;	//3		//2
		this.monitor2 = monitor2;	//2		//1
		this.monitor3 = monitor3;	//1		//1
	}

	@Override
	//die ausgabe ist nicht vorhersehbar.
	public void run() {
		try {
			synchronized (monitor1) {
				System.out.println(name + " got " + monitor1 + " | sec:" + ((System.currentTimeMillis() - startTime) / 1000));
				Thread.sleep(1000);
			}
			synchronized (monitor2) {
				System.out.println(name + " got " + monitor2 + " | sec:" + ((System.currentTimeMillis() - startTime) / 1000));
				Thread.sleep(1000);
				synchronized (monitor3) {
					System.out.println(name + " got " + monitor3 + " | sec:" + ((System.currentTimeMillis() - startTime) / 1000));
					Thread.sleep(1000);
				}
			}
		} catch (InterruptedException e) {
			throw new RuntimeException(e);
		}
	}
}

die main Methode:

public class Main {
	
	public static void main(String[] args) {
		Thread thread1 = new Thread(new Locker("A", 3, 2, 1));
		Thread thread2 = new Thread(new Locker("B", 2, 1, 1));
		thread1.start();
		thread2.start();
	}
}

ich soll eine Mögliche Ausgabe angeben..
hab das mal um sicher zu sein mal Ausgeben lassen und habe diese Ausgaben erhalten.

B got 2 | sec:0
A got 3 | sec:0
A got 2 | sec:1
B got 1 | sec:1
B got 1 | sec:2
A got 1 | sec:3

ein anderer Versuch:
A got 3 | sec:0
B got 2 | sec:0
B got 1 | sec:1
A got 2 | sec:1
B got 1 | sec:2
A got 1 | sec:3


eigentlich habe ich nur Probleme mit den ineinander geschachtelten synchronized Blöcke.. ich kann die Ausgabe leider nicht nachvollziehen.. wäre nett, wenn mich jemand aufklären würde..
Mir ist übrigens klar, dass beim Autoboxing kleiner ganzen Zahlen eindeutige Wrapperobjekte entstehen..

bin für jede Hilfe dankbar..
mfg

 

[Gucky]

Verschachtelung bei synchronized ist nicht sinnvoll. Dann kann trotzdem immer nur ein Thread die Blöcke betreten,da der erste Thread das Mutex des ersten Blocks die ganze Zeit über hält. Alle anderen müssen vorne warten.