Multithreading - synchronized vs. Lock bei Enum, besserer Stil?

[bubble]

Diesmal eher eine Frage nach dem besseren Stil.

Folgende Situation:
Ich habe folgende Klasse:

public class Bla {  
	public static enum TYP {  
		A,  
		B;  
	}  
  
	private TYP typ;  
  
	public void setTyp(TYP typ) { /*...*/ }  
	public TYP getTyp() { /*...*/ }  
}  

Das ganze läuft in einem Programm, bei dem mehrere Threads auf die gleiche Instanz von Bla zugreifen.

NUn ist es ja so, dass Enumerat-Werte konstanten sind und somit bei

TYP t1 = TYP.A;  
TYP t2 = TYP.A;

t1 == t2 true ergibt.

Dadurch würde ein synchronized (t1) {} für alle TYP.As synchronisieren, was in meiner Situation nicht gewünscht ist, sondern ein Lock für den Member direkt.

Spontan Fallen mir nur 2 Möglichkeiten ein auf einen Enum-Member zu locken.

Variante 1: Ein Lock-Objekt für jeden Member benutzen:

	public TYP getTyp() {  
		lock.aquire();  
		try {  
			return typ;  
		} finally {  
			lock.release();  
		}  
	}

Variante 2: "Leere Klasse" erzeugen, eine Instanz dieser als Member und synchronized-Block darauf anwenden.

  
public final class MyLock {}  

	private final MyLock typLock = new MyLock();  
	public TYP getTyp() {  
		synchronized (typLock) {  
			return typ;  
		}  
	}

Da häufiger die Setter-Funktion als die Getter-Funktion gebraucht wird lohnt es nicht das in Lese- und Schreiblock aufzusplitten.

Nun zu meiner eigentlichen Frage: Welche Variante wäre die bessere? Besser im Sinne von sauberer Stil und Performance?

MfG
bubble