设计模式--单例模式总结

一. 单例模式的功能与注意事项

    功能: 单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些频繁创建销毁的对象，
 使用单例模式可以提高系统性能。
    注意事项: 1.单例模式下想要创建一个类的对象,不能通过new来创建，而是通过调用这个类里面的public
              方法(用来返回唯一的对象)来得到返回值，这样才能保证它的唯一性;
             2.将本类构造器设为私有，则无法通过new来创建对象，使new失效;
             3.通过2项指标(线程安全、懒加载)来评判8种单例模式的优缺点，并且是否可用;
             4.八种单例模式分别为:
               饿汉式(静态常量、静态代码块)
               懒汉式(线程不安全、线程安全、同步代码块、双重检查)
               静态内部类
               枚举方式
    下面将对这8种模式一一写出代码并分析优缺点！

二.单例模式的代码分析与优缺点

1.饿汉式(静态常量)

package cn.edu.design;

public class SingleExample {
    public static void main(String[] args){
        Singletonly singletonly1 = Singletonly.getInstance();
        Singletonly singletonly2 = Singletonly.getInstance();//以public函数来获取对象
        System.out.println(singletonly1 == singletonly2);//测试两次实例化的对象是否是同一个，即指向同一个地址
        System.out.println(singletonly1.hashCode());//输出对象的哈希代码是否相同
        System.out.println(singletonly2.hashCode());


    }
}
class Singletonly{
    private Singletonly(){} //私有化构造函数，防止new来创建对象从而破坏单例原则
    private static final Singletonly instance = new Singletonly();//唯一对象，加载类时一并加载
    public static Singletonly getInstance(){
          return instance;
    }
}

A. 饿汉式的饿，意思是还未调用时就已经加载到内存;
B. 加载类时一并加载的这个对象，得益于JVM底层机制，线程是安全的;
C. 因为与类一并加载到内存中但是不一定会用到，所以有可能会造成空间上的浪费。

2.饿汉式(静态代码块)

package cn.edu.design;

public class SingleExample {
    public static void main(String[] args){
        Singletonly singletonly1 = Singletonly.getInstance();
        Singletonly singletonly2 = Singletonly.getInstance();//以public函数来获取对象
        System.out.println(singletonly1 == singletonly2);//测试两次实例化的对象是否是同一个，即指向同一个地址
        System.out.println(singletonly1.hashCode());//输出对象的哈希代码是否相同
        System.out.println(singletonly2.hashCode());


    }
}
class Singletonly{
    private Singletonly(){} //私有化构造函数，防止new来创建对象从而破坏单例原则
    private static Singletonly instance;
    static{
         instance = new Singletonly();
    }
    public static Singletonly getInstance(){
          return instance;
    }
}

A. 与静态常量的唯一区别是，这里将新建对象的行为放在了一个静态代码块static{}中;
B. 线程安全;
C. 未实现懒加载，空间可能性浪费。

3.懒汉式(线程不安全)

package cn.edu.design;

public class SingleExample {
    public static void main(String[] args){
        Singletonly singletonly1 = Singletonly.getInstance();
        Singletonly singletonly2 = Singletonly.getInstance();//以public函数来获取对象
        System.out.println(singletonly1 == singletonly2);//测试两次实例化的对象是否是同一个，即指向同一个地址
        System.out.println(singletonly1.hashCode());//输出对象的哈希代码是否相同
        System.out.println(singletonly2.hashCode());


    }
}
class Singletonly{
    private Singletonly(){} //私有化构造函数，防止new来创建对象从而破坏单例原则
    private static Singletonly instance;//默认初始化为null
    public static Singletonly getInstance(){
          if(instance == null){
          		instance = new Singletonly();
          }
          return instance;
    }
}

A. 懒汉式的懒，意思是加载类时并不会先创建这唯一的对象，只有外部通过getInstance()函数想获得这个对象时，才会临时创建;
B. 线程不安全: 因为有多个线程时，都调用这个getInstance()方法，那么也就会几个线程都刚好过了判断语句，就创建了不止一个对象，破坏了单例规则；
C. 虽然实现了懒加载，但还是不推荐使用。

4.懒汉式(线程安全)

package cn.edu.design;

public class SingleExample {
    public static void main(String[] args){
        Singletonly singletonly1 = Singletonly.getInstance();
        Singletonly singletonly2 = Singletonly.getInstance();//以public函数来获取对象
        System.out.println(singletonly1 == singletonly2);//测试两次实例化的对象是否是同一个，即指向同一个地址
        System.out.println(singletonly1.hashCode());//输出对象的哈希代码是否相同
        System.out.println(singletonly2.hashCode());


    }
}
class Singletonly{
    private Singletonly(){} //私有化构造函数，防止new来创建对象从而破坏单例原则
    private static Singletonly instance;//默认初始化为null
    public static synchronized Singletonly getInstance(){
          if(instance == null){
          		instance = new Singletonly();
          }
          return instance;
    }
}

A. 与线程不安全的唯一区别就是在创建按对象的方法getInstance上加了一个同步锁–sychronized，这个锁保证了线程安全，但是极大的降低了进程效率;
B. 实现了懒加载，实现了线程安全，但是考虑到效率问题，不推荐使用。

5.懒汉式(同步代码块)

package cn.edu.design;

public class SingleExample {
    public static void main(String[] args){
        Singletonly singletonly1 = Singletonly.getInstance();
        Singletonly singletonly2 = Singletonly.getInstance();//以public函数来获取对象
        System.out.println(singletonly1 == singletonly2);//测试两次实例化的对象是否是同一个，即指向同一个地址
        System.out.println(singletonly1.hashCode());//输出对象的哈希代码是否相同
        System.out.println(singletonly2.hashCode());


    }
}
class Singletonly{
    private Singletonly(){} //私有化构造函数，防止new来创建对象从而破坏单例原则
    private static Singletonly instance;//默认初始化为null
    public static Singletonly getInstance(){
          if(instance == null){
          		synchronized(Singletonly.class){
					instance = new Singletonly();
                }
          }
          return instance;
    }
}

A. 与线程安全的区别是，线程安全的同步锁加到了方法上，而这里，加到了创建对象之前。但并没有用，没有解决线程安全的问题；
B. 这个方法旨在解决加上同步锁后的效率问题，但反而又把线程安全问题暴露出来了。

6.懒汉式(双重检查)

package cn.edu.design;

public class SingleExample_lazy {
    public static void main(String[] args){
        Singletonly singletonly1 = Singletonly.getInstance();
        Singletonly singletonly2 = Singletonly.getInstance();
        System.out.println(singletonly1 == singletonly2);
        System.out.println(singletonly1.hashCode());
        System.out.println(singletonly2.hashCode());


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

A. 与同步代码块的区别是，在同步代码块下，又加了一层判断。多个线程都经过第一个if语句后，其中一个线程上锁并创建对象，解锁之后其他线程上锁创建对象时发现对象已创建便不会再去创建，实现了线程安全;
B. 创建对象在public方法getInstance()中，实现了懒加载，并且不存在效率问题，推荐使用！

7.静态内部类

package cn.edu.design;

public class SingleExample_static {
    public static void main(String[] args){
        SingleStatic singlestatic1 = SingleStatic.getInstance();
        SingleStatic singlestatic2 = SingleStatic.getInstance();
        System.out.println(singlestatic1 == singlestatic2);
        System.out.println(singlestatic1.hashCode());
        System.out.println(singlestatic2.hashCode());

    }
}
class SingleStatic{
    private SingleStatic(){}

    private static class SingleStaticInstance { //加载类时不会加载
        private static final SingleStatic instance = new SingleStatic();
    }
    public static SingleStatic getInstance(){ //获取对象时再加载，实现了懒加载，节省了空间
        return SingleStaticInstance.instance;
    }
}

A. 静态内部类并不会一开始就加载，而是在调用getInstance()时再去加载，实现了懒加载，消除了空间浪费的可能性；
B. 这个方法利用了JVM底层机制的优势，不存在线程安全的问题;
C. 没有加锁，也不存在效率上的劣势，推荐使用。

8.枚举方式

package cn.edu.design;

public class SingleEnum {
    public static void main(String[] args){
        Singlemeiju singlemeiju1 = Singlemeiju.instance;
        Singlemeiju singlemeiju2 = Singlemeiju.instance;
        System.out.println(singlemeiju1==singlemeiju2);
        System.out.println(singlemeiju1.hashCode());
        System.out.println(singlemeiju2.hashCode());
        singlemeiju2.sayOK();
    }
}
enum Singlemeiju{
    instance;
    public void sayOK(){
        System.out.println("ok");
    }
}

A. 解决了线程安全的问题;
B. 防止反序列化重新创建新的对象

以上是我的个人总结，希望对学习设计模式的同志有所帮助！