单例模式:
立即加载的单例模式--饿汉模式
public class Singleton {
//当构造方法私有化后,无法在当前类的外部去通过构造方法产生对象
// 创建本类的私有构造方法
private Singleton(){}
private static Singleton singleton = new Singleton();
// 提供一个静态方法 返回当前的对象
public static Singleton getInstance(){
return singleton;
}
}
延迟加载的单例模式--懒汉模式
/**
* 延迟加载的单例模式--懒汉模式
* 不要直接在类加载时实例化,而是在调用方法时,再实例化
* 优点:不会占用内存
* 能不能改动代码 使他变得安全呢?怎么该?
*/
public class LazySingleton {
private LazySingleton(){}
private volatile static LazySingleton singleton;
/* 实例 会在调用getInstance方法时创建 线程不安全的
安全 单线程情况下,是安全的,但是在多线程下,
多个线程可能同时执行singleton == null都为true,
会创建多个实例在内存中
*/
public static LazySingleton getInstance(){
if(singleton == null){
singleton = new LazySingleton();
}
return singleton;
}
/* 线程安全的 但是效率低 需要同步,仅在第一次调用初始化时
锁的粒度太大,影响了程序的执行效率*/
public static synchronized LazySingleton getInstance(){
if(singleton == null){
singleton = new LazySingleton();
}
return singleton;
}
/* 双重检验 首先先判断实例是否为null,
为null则使用synchronized锁住类 ,
然后在同步块中,再一次判断实例是否为null,为null则初始化实例
synchronized(需要锁的对象){}
*/
public static LazySingleton getInstance(){
if(singleton == null){// 判断对象是否被初始化
// 对象没有被初始化,则加上类锁
synchronized (LazySingleton.class){
// 同时只有一个线程能够到这里
if(singleton == null){
// 创建实例对象
singleton = new LazySingleton();
}
}
}
// 实例对象的引用
return singleton;
}
}
静态内部类--创建单例模式
/**
* 通过静态内部类 完成单例模式的创建
* 在外部类加载时,并不会加载内部类,也就是不会执行new 实例(),这属于懒加载
* 只有第一次调用getInstance方法时,才会加载
*/
public class InnerSingleton {
private InnerSingleton(){}
// 静态内部类
private static class Inner{
private static InnerSingleton instance = new InnerSingleton();
}
public static InnerSingleton getInstance(){
return Inner.instance;
}
}
/**
* 通过枚举创建 单例模式
*/
public class EnumSingleton {
private EnumSingleton(){}
private static enum SinEnum{
// 自定义的枚举值
TEST;
private EnumSingleton es = new EnumSingleton();
}
public static EnumSingleton getInstance(){
SinEnum s = SinEnum.TEST;
return s.es;
}
}