这是最简单的实现,把类的构造函数写成private的,从而保证别的类不能实例化此类,然后在类中提供一个静态的实例并能够返回给使用者。这样,使用者就可以通过这个引用使用到这个类的实例了。public class Singleton {
private static Singleton instace;
private Singleton(){}
public static Singleton getInstace(){
if(instace == null){
instace = new Singleton();
}
return instace;
}
}
解决的方法也很简单,那就是加锁,一个线程必须等待另外一个线程创建完成后才能使用这个方法,这就保证了单例的唯一性。public class Singleton {
private static Singleton instace;
private Singleton(){}
public static synchronized Singleton getInstace(){
if(instace == null){
instace = new Singleton();
}
return instace;
}
}
缺点:效率很低,多数情况下不需要同步。
或者public class Singleton {
private static Singleton instance = new Singleton();
private Singleton (){}
public static Singleton getInstance() {
return instance;
}
}
优缺点:public class Singleton {
private static Singleton instace;
static{
instace = new Singleton();
}
private Singleton(){}
public static Singleton getInstace(){
return instace;
}
}
这种方式同样利用了 classloder 的机制来保证初始化 instance 时只有一个线程,它跟第三种比区别如下:public class Singleton {
private static class SingletonClassInstance{
private static final Singleton instace = new Singleton();
}
private Singleton(){}
public static final Singleton getInstace(){
return SingletonClassInstance.instace;
}
}
关于 volatile ,是因为如下原因:public class Singleton {
private volatile static Singleton instance;
private Singleton(){}
public static Singleton getInstace(){
if(instance == null)
{
synchronized (Singleton.class){
if(instance == null){
instance = new Singleton();
}
}
}
return instance;
}
}