单例模式确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例,这个类称为单例类,它提供全局访问的方法。
一是某个类只能有一个实例;
二是它必须自行创建这个实例;
三是它必须自行向整个系统提供这个实例。
单例模式是一种对象创建型模式。
饿汉式:在类加载的时候就会自动创建,多线程访问下也可以正常运行
public class HungryType { private static final HungryType instance = new HungryType(); private HungryType(){ } public static HungryType GetInstance() { return instance; } public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { HungryType ht = HungryType.GetInstance(); Class<?> classType=HungryType.class; //通过反射机制调用私有的构造器。 Constructor<?> c = classType.getDeclaredConstructor(); c.setAccessible(true); HungryType newht=(HungryType)c.newInstance(); System.out.println(ht==newht); } }
懒汉式:好处就是延时加载,在需要的时候再加载
普通懒汉式:
public class SluggardType { private static SluggardType instance = null; private SluggardType() { } public static SluggardType getInstance(){ if(instance == null){ instance = new SluggardType(); } return instance; } }
在多线程访问的情况下,可能会执行多次new的操作双重检验锁的方式来改进:
这里为什么需要两个判空,仅仅最里面的一层,在多线程的情况下,就会创建多个实例,因此在外面加了一层锁,但是这样所有的线程来的时候都会进入临界区再出来,导致大量线程阻塞,影响性能,因此我们在外面再加一层判空,在实例创建以后既不会进入临界区等待了。
public class SluggardType { private volatile static SluggardType instance = null; private SluggardType() { } public static SluggardType getInstance(){ if(instance == null){ synchronized(SluggardType.class){ if(instance==null) instance = new SluggardType(); } } return instance; } }
上面这张双重校验锁是我们用到的最多的情况,我们通过这个例子再来理解一些volatile关键字。
假如这里不加volatile关键字会怎么样?
线程A执行instance = new SluggardType()的时候会发生指令重排,分配内存空间以后,就变量直接指向内存空间(这个时候并没有初始化对象)
线程B执行的时候判断instance不为空,就直接返回,实际上这个时候instance并没有完成初始化。
下面这种方案可以不用volatile关键字
通过静态内部类的方式来实现单例模式,同时解决了多线程访问的问题
public class InnerClassSingleton { //静态内部类的实例与外部的实例没有关系,可以等到用的时候再加载,而且只会被加载一次 private static class SingletonHolder { private static InnerClassSingleton instance = new InnerClassSingleton(); } private InnerClassSingleton() { } //延时操作并没有增加任何访问成本 public static InnerClassSingleton getInstance() { return SingletonHolder.instance; } }
!但是以上的所有情况都可以通过反射来破坏我们的单例模式
因此就有了通过枚举来实现单例模式
public enum EnumSingleton { INSTANCE;
//枚举实现的单例模式就可以保证我们的构造函数只会被执行一次 private EnumSingleton() { } public void test() { System.out.println("test"); } public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { Class<?> classType=EnumSingleton.class; //通过反射机制调用私有的构造器。 Constructor<?> c = classType.getDeclaredConstructor(); c.setAccessible(true); EnumSingleton newes=(EnumSingleton)c.newInstance(); newes.test();//以上会报错抛出异常 EnumSingleton es=EnumSingleton.INSTANCE; es.test(); //输出test } }