单例模式（懒汉式和饿汉式）

概念

单例模式是指保证某个类在整个软件系统中只有一个对象实例，并且该类仅提供一个返回其对象实例,由于单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁地创建、销毁时，而且创建或销毁时性能又无法优化，单例模式的优势就非常明显。

在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。选择单例模式是为了避免不一致状态。

单例常见方式

饿汉式（线程安全）

饿汉就是类一旦加载，单例初始化就开始，保证在调用getInstance()方法时，单例是已经存在的了，以后不再改变，所以是线程安全的。
缺点：当类装载的时候就会创建类的实例，不管你用不用，都会先创建出来，无法做到延迟创建对象，从而降低内存的使用率。

/*
饿汉单例模式设计:
①使用private修饰构造函数，限制了外部创建该类对象
②创建一个静态的对象，在类初始化时，已经自行实例化。
③声明一个getInstance方法来返回该静态对象
*/
public class SingletonPattern {
  private static final SingletonPattern single=new SingletonPattern();
  private SingletonPattern(){}
  static public SingletonPattern getInstance(){
  return single;
   }
}

懒汉式（线程不安全）

懒汉模式中，在第一次调用的时候实例化自己，也就是说只有当调用getInstance()的时候，并且判断 instance为null时才创建一个实例。被动地创建实例。

/*设计:
①构造函数私有，避免外部创建对象（但是Java反射机制是能够实例化构造方法为private的类的，会使Java单例实现失效）
②声明当前类的引用,此时不能对引用进行实例化
③声明getInstance()方法，懒汉式单例的实现没有考虑线程安全问题，	它是线程不安全的，并发环境下可能出现多个实例，要保证线程安全，可以使用 synchronized将方法声明为同步方法，双重检查锁定，或者静态内部类，根据当前对象判断是否为null来创建对象。
*/

线程不安全的懒汉式

public class SingletonPattern2 {
    private static SingletonPattern2 singe=null;
    private SingletonPattern2(){}
    public  static SingletonPattern2 getInstance(){
       if (singe==null){
           singe=new SingletonPattern2();
       }
        return singe;
    }
}

线程安全的懒汉式

1、在getInstance方法上加同步

public class SingletonPattern2 {
    private static SingletonPattern2 singe=null;
    private SingletonPattern2(){}
    public synchronized static SingletonPattern2 getInstance(){
       if (singe==null){
           singe=new SingletonPattern2();
       }
        return singe;
    }
}

2、双重检查锁定

public class SingletonPattern2 {
    private static SingletonPattern2 singe=null;
    private SingletonPattern2(){}
    public synchronized static SingletonPattern2 getInstance(){
        if (singe==null){
            synchronized (SingletonPattern2.class){
                if (singe==null){
                    singe=new SingletonPattern2();
                }
            }
        }
        return singe;
    }
}

3、静态内部类

public class SingletonPattern2 {
    private SingletonPattern2(){}
    public static class LazyHolder{
        private static SingletonPattern2 singe=new SingletonPattern2();
    }
    public  static SingletonPattern2 getInstance() {
        return LazyHolder.singe;
    }
}

测试

public class Test {
public static void main(String[] args) {
//饿汉式（线程安全）
SingletonPattern instance =SingletonPattern.getInstance();
SingletonPattern instance2 =SingletonPattern.getInstance();
//判断是否是一个对象实例
System.out.println(instance==instance2);//true

//懒汉式（线程不安全）
SingletonPattern2 instance3 =SingletonPattern2.getInstance();
SingletonPattern2 instance4 =SingletonPattern2.getInstance();
//判断是否是一个对象实例
System.out.println(instance3==instance4);//true
  }
}

懒汉式和饿汉式区别

饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题，

懒汉式本身是非线程安全的，为了实现线程安全有以上几种写法。

懒汉模式和饿汉模式的实例创建的时机不同；

单例模式的应用场景

某类只要求生成一个对象的时候，如一个班中的班主任。

单例模式为一个面向对象的应用程序提供对象惟一的访问点，整个应用程序同享一个实例对象。

某类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池