饿汉式
直接创建对象,不管你是否需要这个对象,都会创建,思想如下。
1.构造器私有化
2.自行创建,并且用静态变量保存
3.向外提供这个实例
4.强调这是个单例,可以用final修改
代码实现:
/**
* TODO 饿汉式 写法一
* 1.构造器私有化
* 2.自行创建,并且静态变量保存 (为了强调这是一个单例类,可以用final修饰)
* 3.向外提供这个实例
*/
public class Singleton1 {
private static final Singleton1 Instance = new Singleton1();
private Singleton1() {
}
public static Singleton1 GetInstance(){
return Instance;
}
}
/**
* TODO 饿汉式 写法二
* 创建一个枚举类型的类(创建类的时候选取枚举类型) ,枚举表示该类对象为有限的,
* 可以设定为一个,即为单例,且枚举类的构造器是私有的。
*
* 而且枚举类, 重写了tostring方法,输出的不是地址,而是实例对象的名字.
*/
public enum Singleton2 {
Instance;
}
/**
* TODO 饿汉式 写法三
* 如果需要构造复杂的对象,可以使用静态代码块来实现。
* 假设参数info 在类路径下single.properties 中
*/
public class Singleton3 {
public static final Singleton3 INSTANCE;
private String info;
private Singleton3(String info)
{
this.info = info;
}
static {
try {
Properties pro = new Properties();
pro.load(Singleton3.class.getClassLoader().getResourceAsStream("single.properties"));
INSTANCE = new Singleton3(pro.getProperty("info"));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
懒汉式
可以使对象的延时加载。
创建步骤如下:
1.构造器私有化
2.用一个静态变量保存这个唯一的实例
3.提供一个静态方法,获取这个实例对象
//优化的 DCL实现方式
public class Singleton4 {
private static volatile Singleton4 Instance;
private Singleton4(){}
public static Singleton4 getInstance () {
if(Instance == null){
synchronized(Singleton4.class){
if(Instance == null)
Instance = new Singleton4();
}
}
return Instance;
}
}
/**
* 以静态内部类存放实例对象
* 既能保证线程安全,也能延迟加载在内部类被加载和初始化时,才创建对象。
* 静态内部类不会自动随着外部类的加载和初始化而初始化,它是要单独加载和初始化的。
* 因为是在内部类加载和初始化时,创建的,因此是线程安全的。
*/
public class Singleton5 {
private Singleton5(){
}
public static class Inner{
private static final Singleton5 INSTANCE =new Singleton5();
}
public static Singleton5 getInstance(){
return Inner.INSTANCE;
}
}
Thanks for watching~