Eine statische Klasse mit einer Menge statischer Variablen ist ein Hack.
/**
* Grotty static semaphore
**/
public static class Ugly {
private static int count;
public synchronized static void increment(){
count++;
}
public synchronized static void decrement(){
count--;
if( count<0 ) {
count=0;
}
}
public synchronized static boolean isClear(){
return count==0;
}
}
Ein Singleton mit einer tatsächlichen Instanz ist besser.
/**
* Grotty static semaphore
**/
public static class LessUgly {
private static LessUgly instance;
private int count;
private LessUgly(){
}
public static synchronized getInstance(){
if( instance==null){
instance = new LessUgly();
}
return instance;
}
public synchronized void increment(){
count++;
}
public synchronized void decrement(){
count--;
if( count<0 ) {
count=0;
}
}
public synchronized boolean isClear(){
return count==0;
}
}
Der Status befindet sich NUR in der Instanz.
So kann der Singleton später geändert werden, um Pooling, threadlokale Instanzen usw. durchzuführen. Und keiner der bereits geschriebenen Codes muss geändert werden, um den Vorteil zu erzielen.
public static class LessUgly {
private static Hashtable<String,LessUgly> session;
private static FIFO<LessUgly> freePool = new FIFO<LessUgly>();
private static final POOL_SIZE=5;
private int count;
private LessUgly(){
}
public static synchronized getInstance(){
if( session==null){
session = new Hashtable<String,LessUgly>(POOL_SIZE);
for( int i=0; i < POOL_SIZE; i++){
LessUgly instance = new LessUgly();
freePool.add( instance)
}
}
LessUgly instance = session.get( Session.getSessionID());
if( instance == null){
instance = freePool.read();
}
if( instance==null){
// TODO search sessions for expired ones. Return spares to the freePool.
//FIXME took too long to write example in blog editor.
}
return instance;
}
Es ist möglich, mit einer statischen Klasse etwas Ähnliches zu tun, aber der indirekte Versand verursacht einen Overhead pro Anruf.
Sie können die Instanz abrufen und als Argument an eine Funktion übergeben. Dadurch kann der Code an den "richtigen" Singleton gerichtet werden. Wir wissen, dass Sie nur eines davon brauchen ... bis Sie es nicht tun.
Der große Vorteil besteht darin, dass zustandsbehaftete Singletons threadsicher gemacht werden können, während eine statische Klasse dies nicht kann, es sei denn, Sie ändern sie als geheimen Singleton.