潍坊手机网站制作西安seo关键词排名优化

在整个程序中，保持只有一个实例对象，就是单例模式。

单例模式可以减少构建，GC的次数，提升性能，还能减少堆内存的开销。

1. 懒汉式

• 在需要使用对象的时候，才进行创建

• 通过private构造方法，确保外部不能new出对象，通过一个静态方法进行对象获取。

public  class LazySingleton implements Serializable {private static LazySingleton lazySingleton = null;private  LazySingleton() {}public  static LazySingleton  getInstance(){if(lazySingleton == null){lazySingleton = new LazySingleton();}return lazySingleton;}
}

 需要注意的是，懒汉式是线程不安全的，并发情况下有线程安全问题，需要进行同步处理。

可以在getInstance()方法上加上synchronized。但是锁的粒度很大，所以引出了双重检查锁

2. 双重检查锁

• 通过两个if判断,加上同步锁进行实现
• 只进行一次判断上锁的话，上锁解锁后，单例对象就被重置了，因为有可能多个线程同时都通过了第一次判断，只是没抢到锁
• 而且，需要加上volatile保证可见性和同步性，因为锁住的是class对象，不是单例对象，所以JMM保证的unlock刷到主存，lock读到工作内存只对class对象起作用，单例对象的可见性无法保证，同样的，是class对象的unlock操作在lock操作之前，happens before原则也无法保证有序性，因为整个临界区内根本找不到一个和class对象相关的操作。

public class DoubleCheckSingleton {private static volatile  DoubleCheckSingleton doubleCheckSingleton ;private DoubleCheckSingleton(){}public static DoubleCheckSingleton getInstance(){if(doubleCheckSingleton ==null){synchronized (DoubleCheckSingleton.class){if (doubleCheckSingleton == null){doubleCheckSingleton = new DoubleCheckSingleton();}}}return doubleCheckSingleton;}
}

 3. 静态内部类

双重检查锁对于同步控制特别的复杂繁琐，有没有什么底层已经进行了的同步操作可以利用的呢？

答案是类加载的loadclass是被synchronized修饰的，类的加载是同步的，类加载进行到初始化部分的时候会对静态变量赋初始值，也会执行静态代码块。

• 在单例类中,通过私有的静态内部类,创建单例对象

• 静态内部类只有在被调用的时候才会被加载，实现了懒加载。

public class StaticInnerClassSingleton {/*** 第一次被调用到的时候才会进行类加载，进行初始化（JVM相关知识，加载、连接（验证，准备，解析）、初始化（为静态变量赋值）*/private static class InnerClass{private static final StaticInnerClassSingleton staticInnerClassSingleton = new StaticInnerClassSingleton();}private StaticInnerClassSingleton(){System.out.println("StaticInnerClassSingleton初始化......");}public static StaticInnerClassSingleton getInstance(){return InnerClass.staticInnerClassSingleton;}
}

4. 饿汉式

如果不追求懒加载，那么还是使用类加载的同步控制的话，直接在单例类放一个静态变量，或者在静态代码块进行初始化。

public class HungrySingleton {private static final HungrySingleton hungrySingleton ;static {hungrySingleton = new HungrySingleton();}private HungrySingleton(){System.out.println("HungrySingleton初始化.....");}public static HungrySingleton getInstance(){return hungrySingleton;}
}

5. 枚举

前面一步一步的推导出到了饿汉式，看着很完美了，但是单例模式会被反射破坏。通过反射获取到构造函数后，可以强制开启权限执行。序列化和反序列化也都是基于反射创建对象的。

那么什么单例模式不会有这样的情况呢？

枚举。枚举是最佳的单例模式实现方式。

枚举在底层的构造函数是强制private的，反射无法打开权限，枚举对象的反序列化是通过name在堆内找到对应的对象

public enum EnumSingleton implements Serializable {EnumSingleton("枚举单例");private String name;EnumSingleton() {}EnumSingleton(String name) {this.name = name;}public void doSomething(String something) {System.out.println(name + ":" + something);}
}