单例模式的理解与学习

单例模式：

单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态。

特点是：单例类只能够有一个实例，必须自己给自己创建唯一的实例，单例类，必须给其他的对象对对象提供这一实例。

单例模式的实现方式：

一）饿汉式：

饿汉式单例在类加载初始化时就创建好一个静态的对象供外部使用，除非系统重启，这个对象不会改变，所以本身就是线程安全的。

public class Singleton {
    /**
     * 实现单例模式
     * 饿汉式的方式，其线程是安全的，原因就是在于在类加载初始化的时候就创建好了一个静态的对象共外部使用的勒
     * 除非系统进行重启，否则的这个对象是无法进行改变的，
     */
    public Singleton() {
        System.out.println("构造函数Singleton执行");
    }
    /**
     * 初始化实例的对象
      */
    private  static Singleton singleton=new Singleton();
    /**
     * 静态的工厂的方法
     *
     */
    public static  Singleton getInstance(){
        System.out.println("getInstance");
        return singleton;
    }

    public static void main(String[] args) {
        System.out.println("初始化");
        Singleton singleton=Singleton.getInstance();
    }
}

 

 

 二）懒汉式（延迟加载） 

延迟方式实现了懒汉式单例，但是在多线程的环境下会实现多个Singleton的对象

public class LazySingleton {
    public LazySingleton() {
        System.out.println("构造函数LazySingleton");
    }
    /**
     * 赋初始值
     */
    private static LazySingleton lazySingleton=null;
    public static LazySingleton getInstance(){
        if(lazySingleton==null){
            System.out.println("getInstance");
            lazySingleton=new LazySingleton();
        }
        return lazySingleton;
    }

    public static void main(String[] args) {
        System.out.println("初始化");
        LazySingleton lazySingleton= LazySingleton.getInstance();
    }
}

虽然饿汉式的线程是安全的，原因就是在于使用private进行修饰，使得处于同一个虚拟机的范围内Singleton的唯一的实例只有通过getInstance（）方法进行访问的（但是可以通过反射的技术可以 进行单例模式失效）

但是懒汉式是在饿汉式的方式上进行了延迟的，如果在多线程的环境下就会创建多个对象。因此可以加上同步锁的方式来解决线程安全的问题。

public class LazySingletonSynchronize {
    public LazySingletonSynchronize() {
        System.out.println("私有的构造方法");
    }
    private static LazySingletonSynchronize lazySingletonSynchronize=null;
    public static LazySingletonSynchronize getInstance(){
        synchronized (LazySingletonSynchronize.class){
            if(lazySingletonSynchronize==null){
                lazySingletonSynchronize=new LazySingletonSynchronize();
            }
        }
        return lazySingletonSynchronize;
    }
}

 但是在懒汉式的方式下加上同步锁的机制后，虽然解决了多个实例对象的问题，但是说，运行的效率将会降低很多，下一个线程想要去获取对象，就必须得等到上一个线程释放后才能够进行。因此可以尝试对锁的部分加锁，以此来提高执行的效率。

    public LazySingletonSynchronize() {
        System.out.println("构造方法");
    }
    private static LazySingletonSynchronize lazySingletonSynchronize=null;
    public static LazySingletonSynchronize getInstance(){
        if(lazySingletonSynchronize==null){
            synchronized(LazySingletonSynchronize.class){
                if(lazySingletonSynchronize==null){
                    lazySingletonSynchronize=new LazySingletonSynchronize();
                }
            }
        }
        return lazySingletonSynchronize;
    }