1.设计模式-单例模式

实现单例模式的三种方式

单例模式一般分为【懒汉式、饿汉式、枚举式】

懒汉式

package com.example.demo.singleton;
/**
 * 懒汉式-单例
 */
public class LzSingleton {
    // 线程非安全的
//    private static LzSingleton lzSingleton;

    public static String a = "a";
	
    private static volatile LzSingleton lzSingleton;
    private LzSingleton(){}

    // 线程非安全的
//    public static LzSingleton getInstance(){
//        if (lzSingleton == null){
//            lzSingleton = new LzSingleton();
//        }
//        return lzSingleton;
//    }
    private static final class HolderSingleton{
        private static LzSingleton singleton = new LzSingleton();
    }

    // 线程安全 -- 双重检验锁
    public static LzSingleton getInstance(){
        if (lzSingleton == null){
            synchronized(LzSingleton.class){
                if (lzSingleton == null){
                    lzSingleton = new LzSingleton();
                }
            }
        }
        return lzSingleton;
    }

    public static LzSingleton getHolderInstance(){
        return HolderSingleton.singleton;
    }
    
    // 防止序列化、反序列化实例对象
    public static Object readResolve(){
        return lzSingleton;
    }

    public void print(){
        System.out.println("懒汉式");
    }
}

其中注释部分为非线程安全的写法。

1. getInstance()是其中一种线程安全的写法，采用的是双重检验锁，既保证了线程安全，又保证了执行效率。
2. getHolderInstance() 采用的是内部类形式，相当于即调用内部类就变成一个饿汉式的形式。
3. readResolve() 是防止序列化后new LzSingleton(),如果类包含readResolve的方法名，则序列化之后获取的实例就是从这里面返回的。

饿汉式

package com.example.demo.singleton;
/**
 * 饿汉式 -- 单例
 */
public class Singleton {
    public static String a = "a";
//    private static Singleton singleton = new Singleton();
    private static Singleton singleton = null;
    private Singleton(){}
    static {
        if (singleton == null){
            singleton = new Singleton();
        }
    }
    public static Singleton getInstance(){
        return singleton;
    }

    public static Object readResolve(){
        return singleton;
    }

    public static void print(){
        System.out.println("饿汉式");
    }
}

1. 饿汉式这个写法是把实例对象放在静态代码块中，只要调用这个类里的任何变量，方法，即会强行实例对象。
2. readResolve()和懒汉式的效果一样

枚举式

我们可以先看一下源代码

package com.example.demo.singleton;
/**
 * 枚举单例
 */
public enum EnumSingleton {
    INSTANCE;
    public void print(){
        System.out.println("枚举式单例");
    }
}

然后再看一下编译后的代码 javap -p EnumSingleton

public final class EnumSingleton extends java.lang.Enum<EnumSingleton> {
  public static final EnumSingleton INSTANCE;
  private static final EnumSingleton[] $VALUES;
  public static EnumSingleton[] values();
  public static EnumSingleton valueOf(java.lang.String);
  private EnumSingleton(); 
  public void print();
  static {};
}

可以看到一个枚举经过编译后，它就转换成一个最终类并且继承了java.lang.Enum
而且这个编译后的类，他有一个private（私有）的构造方法，我们在枚举里写得INSTANCE编译后变成一个public static final EnumSingleton INSTANCE（公开静态常量），因为是final修饰的，所以它只能被实例化一次，并且是在static{}静态代码块中进行实例的（饿汉式），而且枚举不能被序列化。
重点是，重点是，重点是，枚举写单例代码极为简洁。