1.单例模式的应用场景
单例模式是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建型模式。单例模式在现实生活中应用也非常广泛；例如，公司CEO、部门经理。J2EE标准中的ServletContext、ServletContextConfig 等、Spring框架应用中的ApplicationContext、数据库的连接池等也都说单例模式。
1.饿汉式单例模式
饿汉式单例模式在类加载时候就立即初始化，并且创建单例对象。它绝对线程安全，在线程还没出西安以前就实例化了，不可能存在访问安全问题。
优点： 没有加任何锁、执行效率比较高，用户体验比懒汉式单例模式更好。
缺点： 类加载的时候就初始化，不管用与不用都占着空间，浪费了内存。
Spring中的IoC容器ApplicationContext 本身就是典型的饿汉式单例模式。
实例：
饿汉式单例模式：
//饿汉式单例模式
public class Hungry {
//私有构造器
private Hungry(){}
private final static Hungry HUNGRY = new Hungry();
//对外提供接口
public static Hungry getInstance(){
return HUNGRY;
}
}
饿汉式静态块单例模式：
//饿汉式静态块单例模式
public class HungryStaticSingleton {
private static final HungryStaticSingleton HUNGRY_STATIC_SINGLETON;
private HungryStaticSingleton(){}
static {
HUNGRY_STATIC_SINGLETON = new HungryStaticSingleton();
}
public static HungryStaticSingleton getInstance(){
return HUNGRY_STATIC_SINGLETON;
}
}
2.懒汉式单例模式
特点： 被外部类调用的时候内部类才会加载。
//懒汉式单例模式
public class LazySimpleSingleton {
private LazySimpleSingleton(){}
private static LazySimpleSingleton lazy = null;
private static LazySimpleSingleton getInstance(){
if (lazy == null){
lazy = new LazySimpleSingleton();
}
return lazy;
}
}
存在问题： 可能会造成线程不安全。接下来解决问题：
通过synchronized解决线程安全问题，但仍然能通过反射来破坏单例模式。
//懒汉式单例模式 通过synchronized解决线程安全问题
public class LazySimpleSingleton {
private LazySimpleSingleton(){}
private static LazySimpleSingleton lazy = null;
private static LazySimpleSingleton getInstance(){
if (lazy == null){
synchronized (LazySimpleSingleton.class){
if (lazy == null){
lazy = new LazySimpleSingleton();
//1.分配内存给这个对象
//2.初始化对象
//3.设置lazy指向刚分配的内存地址
}
}
}
return lazy;
}
}
3.静态内部类
这种形式兼顾饿汉式单例的内存浪费问题和synchronized 的性能问题，完美地屏蔽了这两个缺点。
//静态内部类
public class LazyInnerClassSingleton {
private LazyInnerClassSingleton(){}
public static final LazyInnerClassSingleton getInstance(){
return lazyHolder.LAZY;
}
private static class lazyHolder{
private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
}
}
4.演示通过反射来破坏单例
public class LazyInnerClassSingletonTest {
public static void main(String[] args) {
try {
Class clazz = LazyInnerClassSingleton.class;
//通过反射获取私有的构造器
Constructor c = clazz.getDeclaredConstructor(null);
//强制访问
c.setAccessible(true);
//暴力初始化
Object o1 = c.newInstance();
Object o2 = c.newInstance();
System.out.println(o1 == o2);
} catch (Exception e) {
e.printStackTrace();
}
}
}
实验结果：
也就说明了创建两个不同的实例。
进一步修改： 在构造方法中做了一些限制，一旦出西安多次重复创建，则直接抛出异常。
public class LazyInnerClassSingleton {
//如果没有使用，则内部类是不加载的
private LazyInnerClassSingleton(){
if (lazyHolder.LAZY != null){
throw new RuntimeException("不允许创建多个实例");
}
}
public static final LazyInnerClassSingleton getInstance(){
return lazyHolder.LAZY;
}
private static class lazyHolder{
private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
}
}
5.枚举式单例模式
枚举式单例模式是Effective Java书中推荐的一种单例模式实现写法。序列化和反射方法都不能破坏枚举式单例模式。
public enum EnumSingle {
INSTANCE;
public EnumSingle enumSingle(){
return INSTANCE;
}
}
6.小结：
单例模式可以保证内存里只有一个实例，减少了内存的开销，海可以避免对资源的多重占用。
