单例模式
八种设计模式说明
饿汉式(线程安全)
代码
public class Hungry {
private static Hungry hungry = new Hungry();

public Hungry(){}

public static Hungry getInstance(){
    return hungry;
}

}

设计思想
在类加载的时候就把对象创建并放到内存中

问题
饿汉式单例模式是线程安全的,但是该实例在类装载的时候就加入到内存中,可能会造成资源浪费.测试结果

测试结果(创建1000个)
com.yczuoxin.pattern.singleton.hungry.Hungry@46bf5757
com.yczuoxin.pattern.singleton.hungry.Hungry@46bf5757
com.yczuoxin.pattern.singleton.hungry.Hungry@46bf5757
com.yczuoxin.pattern.singleton.hungry.Hungry@46bf5757
com.yczuoxin.pattern.singleton.hungry.Hungry@46bf5757
com.yczuoxin.pattern.singleton.hungry.Hungry@46bf5757
com.yczuoxin.pattern.singleton.hungry.Hungry@46bf5757
com.yczuoxin.pattern.singleton.hungry.Hungry@46bf5757
com.yczuoxin.pattern.singleton.hungry.Hungry@46bf5757
com.yczuoxin.pattern.singleton.hungry.Hungry@46bf5757
com.yczuoxin.pattern.singleton.hungry.Hungry@46bf5757
com.yczuoxin.pattern.singleton.hungry.Hungry@46bf5757
...
cost:139ms

懒汉式(线程不安全)
代码
public class ThreadUnSafeLazy {
private static ThreadUnSafeLazy lazy;

private ThreadUnSafeLazy(){}

public static ThreadUnSafeLazy getInstance(){
    if(null == lazy){
        lazy = new ThreadUnSafeLazy();
    }
    return lazy;
}

}

设计思想
在获取对象时先去判断是否实例化过,如果没有实例化就实例化一个对象

问题
在高并发环境下,如果一个线程访问时该对象还在实例化过程中,那么就会重新再实例化一个对象,导致线程不安全问题.

测试结果(创建1000个)
com.yczuoxin.pattern.singleton.lazy.ThreadUnSafeLazy@7fc8692f
com.yczuoxin.pattern.singleton.lazy.ThreadUnSafeLazy@304a7580
com.yczuoxin.pattern.singleton.lazy.ThreadUnSafeLazy@304a7580
com.yczuoxin.pattern.singleton.lazy.ThreadUnSafeLazy@304a7580
com.yczuoxin.pattern.singleton.lazy.ThreadUnSafeLazy@304a7580
com.yczuoxin.pattern.singleton.lazy.ThreadUnSafeLazy@304a7580
com.yczuoxin.pattern.singleton.lazy.ThreadUnSafeLazy@304a7580
com.yczuoxin.pattern.singleton.lazy.ThreadUnSafeLazy@304a7580
com.yczuoxin.pattern.singleton.lazy.ThreadUnSafeLazy@304a7580
com.yczuoxin.pattern.singleton.lazy.ThreadUnSafeLazy@304a7580
...
cost:98ms

懒汉式(线程安全)
public class ThreadSafeLazy {
private static ThreadSafeLazy lazy;

private ThreadSafeLazy(){}

public static synchronized ThreadSafeLazy getInstance(){
    if(null == lazy){
        lazy = new ThreadSafeLazy();
    }
    return lazy;
}

}

设计思想
由线程不安全的懒汉式可以得出该问题出现在同时两个线程调用了getInstance()方法导致,所以给与该方法加上synchronized加锁,使得该方法只有一个线程访问,保证了线程安全.

问题
synchronized锁会降低性能.增加获取实例的时间.

测试结果(创建1000个)
com.yczuoxin.pattern.singleton.lazy.ThreadSafeLazy@72f7f615
com.yczuoxin.pattern.singleton.lazy.ThreadSafeLazy@72f7f615
com.yczuoxin.pattern.singleton.lazy.ThreadSafeLazy@72f7f615
com.yczuoxin.pattern.singleton.lazy.ThreadSafeLazy@72f7f615
com.yczuoxin.pattern.singleton.lazy.ThreadSafeLazy@72f7f615
com.yczuoxin.pattern.singleton.lazy.ThreadSafeLazy@72f7f615
com.yczuoxin.pattern.singleton.lazy.ThreadSafeLazy@72f7f615
com.yczuoxin.pattern.singleton.lazy.ThreadSafeLazy@72f7f615
com.yczuoxin.pattern.singleton.lazy.ThreadSafeLazy@72f7f615
com.yczuoxin.pattern.singleton.lazy.ThreadSafeLazy@72f7f615
com.yczuoxin.pattern.singleton.lazy.ThreadSafeLazy@72f7f615
com.yczuoxin.pattern.singleton.lazy.ThreadSafeLazy@72f7f615
...
cost:129ms

枚举类(无需测试)
代码
public enum ColorEnum {
RED,
YELLOW,
BLACK,
BLUE
}

说明
枚举类可以作为单例模式是由于其特殊的性质,他在反编译的时候已经变成了final类,并且字段都被static final修饰.所以是枚举类初始化的时候,就已经初识化值了,所以也满足了单例模式的条件.

静态内部类
代码
public class StaticInnerClass {

private StaticInnerClass(){}

static class StaticInnerClassHolder{
    private static final StaticInnerClass statics = new StaticInnerClass();
}

public static StaticInnerClass getInstance(){
    return StaticInnerClassHolder.statics;
}

}

设计思想
只有在使用静态内部类的时候静态内部类才会实例化,只有使用到了静态内部类才会实例化该对象.不会造成对资源的浪费.

问题
创建对象所用时间较长.

测试结果(创建1000个)
com.yczuoxin.pattern.singleton.statics.StaticInnerClass@2d5a99cd
com.yczuoxin.pattern.singleton.statics.StaticInnerClass@2d5a99cd
com.yczuoxin.pattern.singleton.statics.StaticInnerClass@2d5a99cd
com.yczuoxin.pattern.singleton.statics.StaticInnerClass@2d5a99cd
com.yczuoxin.pattern.singleton.statics.StaticInnerClass@2d5a99cd
com.yczuoxin.pattern.singleton.statics.StaticInnerClass@2d5a99cd
com.yczuoxin.pattern.singleton.statics.StaticInnerClass@2d5a99cd
com.yczuoxin.pattern.singleton.statics.StaticInnerClass@2d5a99cd
com.yczuoxin.pattern.singleton.statics.StaticInnerClass@2d5a99cd
com.yczuoxin.pattern.singleton.statics.StaticInnerClass@2d5a99cd
com.yczuoxin.pattern.singleton.statics.StaticInnerClass@2d5a99cd
...
cost:146ms

注册登记式
代码
public class Register {

private static Map<String, Object> registerMap = new ConcurrentHashMap<>();

private Register() {
}

static {
    Register register = new Register();
    registerMap.put(Register.class.getName(), register);
}

public static Object getInstance(String className) {
    if (null == className){
        className = "com.yczuoxin.pattern.singleton.register.Register";
    }
    if (!registerMap.containsKey(className)){
        try {
            registerMap.put(className,Class.forName(className).newInstance());
        } catch (Exception e) {
            System.out.println("请填写正确的类的全路径");
            e.printStackTrace();
        }
    }
    return registerMap.get(className);
}

}

设计思想
用一个容器去装载所有的对象,并在容器中用其类的限定名登记所有的对象,如果实例对象在不存在,我们注册到单例注册表中,第二次取的时候根据类的限定名去取出对应的对象.不需要重新去初始化.

问题
暂无

扩展
Spring就是利用这种方式存放各种Bean.

org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(String)

测试结果(创建1000个)
com.yczuoxin.pattern.singleton.register.Register@4cc45e92
com.yczuoxin.pattern.singleton.register.Register@4cc45e92
com.yczuoxin.pattern.singleton.register.Register@4cc45e92
com.yczuoxin.pattern.singleton.register.Register@4cc45e92
com.yczuoxin.pattern.singleton.register.Register@4cc45e92
com.yczuoxin.pattern.singleton.register.Register@4cc45e92
com.yczuoxin.pattern.singleton.register.Register@4cc45e92
com.yczuoxin.pattern.singleton.register.Register@4cc45e92
com.yczuoxin.pattern.singleton.register.Register@4cc45e92
com.yczuoxin.pattern.singleton.register.Register@4cc45e92
...
cost:108ms

双重校验
代码
public class DoubleCheck {
private static volatile DoubleCheck doubleCheck;

private DoubleCheck(){}

public static DoubleCheck getInstance(){
    if (null == doubleCheck){
        synchronized (DoubleCheck.class){
            if(null == doubleCheck){
                doubleCheck = new DoubleCheck();
            }
        }
    }
    return doubleCheck;
}

}

技术思路
利用volite可见性和synchronized锁保证单例的创建是线程安全的.

问题
volite会使缓存失效,消耗性能,synchronized锁也导致性能的消耗,所以总的说来很耗性能.

测试结果(创建1000个)
com.yczuoxin.pattern.singleton.doublecheck.DoubleCheck@7097d410
com.yczuoxin.pattern.singleton.doublecheck.DoubleCheck@7097d410
com.yczuoxin.pattern.singleton.doublecheck.DoubleCheck@7097d410
com.yczuoxin.pattern.singleton.doublecheck.DoubleCheck@7097d410
com.yczuoxin.pattern.singleton.doublecheck.DoubleCheck@7097d410
com.yczuoxin.pattern.singleton.doublecheck.DoubleCheck@7097d410
com.yczuoxin.pattern.singleton.doublecheck.DoubleCheck@7097d410
com.yczuoxin.pattern.singleton.doublecheck.DoubleCheck@7097d410
...
cost:124ms

序列化
代码
public class Serialize implements Serializable {
private static Serialize serialize = new Serialize();

private Serialize(){}

public static Serialize getInstance(){
    return serialize;
}

protected Object readResolve(){
    return  serialize;
}

}

测试代码
public class SerializableTest {
public static void main(String[] args) {
Serialize serialize = Serialize.getInstance();
System.out.println(serialize);
writeFile("D://serialize.txt", serialize);
Serialize serialized = (Serialize)readFile("D://serialize.txt");
System.out.println(serialized);
}

private static void writeFile(String path, Object object) {
    FileOutputStream fos = null;
    ObjectOutputStream oos = null;
    try{
        fos = new FileOutputStream(new File(path));
        oos = new ObjectOutputStream(fos);
        oos.writeObject(object);
    } catch (Exception e){
        e.printStackTrace();
    } finally {
        try {
            oos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

private static Object readFile(String path) {
    FileInputStream fis = null;
    ObjectInputStream ois = null;
    Object object = null;
    try{
        fis = new FileInputStream(new File(path));
        ois = new ObjectInputStream(fis);
        object = ois.readObject();
    } catch (Exception e){
        e.printStackTrace();
    } finally {
        if (null != ois){
            try {
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (null != fis){
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    return object;
}

}

设计思想
利用序列化和反序列来创建对象,为了使创建的对象是单例,必须实现Serializable接口及重写readResolve(),当实现了readResolve方法后,jvm就会有readResolve返回指定对象,也就保证了单例性.

protected Object readResolve(){
return serialize;
}

缺点
使用起来比较复杂,还要使用到IO读写

测试结果
com.yczuoxin.pattern.singleton.serialize.Serialize@4554617c
com.yczuoxin.pattern.singleton.serialize.Serialize@4554617c

优点
节省资源空间,减少了new对象所消耗的性能,并且可以在任何地方拿到同样的东西.

缺点
当获取对象时不能用new关键字来创建,而要知道其API,增加了开发人员的使用难度.

使用场景
工具类
日志等文件系统
各种资源池(连接池,线程池等)
可以循环使用的对象