1、懒汉式
懒汉式实现代码:
class Singleton2{
private static Singleton2 singleton2 = null;
private Singleton2(){}
public static synchronized Singleton2 getInstance() {
if(singleton2 == null)
singleton2 = new Singleton2();
return singleton2;
}
}
懒汉式在方法调用的时候才会加载,实现了延时加载,但由于通过加锁实现线程安全,效率较低。
2、饿汉式
懒汉式实现代码:
class Singleton1{
private static Singleton1 singleton1 = new Singleton1();
private Singleton1(){}
public static Singleton1 getInstance() {
return singleton1;
}
}
饿汉式在类加载的时候就会创建对象存入内存中,所以是线程安全的,但是也正是这样导致会浪费内存空间。
3、双重检查模式
双重检查模式其实类似于懒汉式,代码如下:
class Singleton4{
private static Singleton4 singleton4 = null;
public static Singleton4 getInstance(){
if (singleton4 == null) {
synchronized (Singleton4.class) {
if (singleton4 == null) {
singleton4 = new Singleton4();
}
}
}
return singleton4;
}
}
这里锁是在代码块中,而不是在方法上,所以需要检查两次,这个同样实现了延时加载,线程安全,但是效率较低。
4、静态内部类
静态内部类的代码如下:
class Singleton3{
private static class Single3Class{
private static final Singleton3 SINGLETON3 = new Singleton3();
}
private Singleton3(){}
public static Singleton3 getInstance() {
return Single3Class.SINGLETON3;
}
}
静态内部类是目前来讲比较好的单例实现方式,只有在方法调用的时候内部类才会被类加载,类加载的时候会创建对象,所以也是线程安全的,并且也实现了延时加载,效率较高。