02设计模式——单例模式

02设计模式——单例模式

单例设计模式：涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

单例模式的结构：

​ 单例类：只能创建一个实例的类

​ 访问类：使用单例类

创建方式有两种：
1.饿汉式 : 类加载就会导致该单实例对象被创建
1）静态常量 2）静态代码块
2.懒汉式 ：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建
1）线程不安全 2）线程安全，同步方法 3）线程安全，同步代码块

创建步骤：
1.构造器私有化（防止new)
2.类的内部创建对象
3.向外暴露一个静态的公共方法。getInstance
4.代码实现

饿汉式（静态常量）

package 饿汉式;

//饿汉式（静态常量）
public class StaticSingleton {
    //1.构造器私有化，外部能new
    private StaticSingleton(){}
    //2.本类内部创建对象实例
    private static StaticSingleton instance = new StaticSingleton();
    //3.提供一个公共的访问方式，让外界获取该对象
    public static StaticSingleton getInstance(){
        return instance;
    }
}

优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。

**缺点：**在类装载的时候就完成实例化，没有达到 Lazy Loading 的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费

这种方式基于 classloder 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，在单例模式中大 多数都是调用 getInstance 方法，但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静 态方法）导致类装载，这时候初始化 instance 就没有达到 lazy loading 的效果

**结论：**这种单例模式可用，可能造成内存浪费

饿汉式（静态代码块）

package 饿汉式;

/**
 饿汉式（静态代码块）
 */
public class StaticSingleton2 {
    //1.构造器私有化，外部能new
    private StaticSingleton2(){}
    //2.本类内部创建对象实例
    private static StaticSingleton2 instance;//null
    static{//在静态代码块中，创建单例对象
        instance = new StaticSingleton2();
    }
    //3.提供一个公有的静态方法，返回实例对象
    public static StaticSingleton2 getInstance(){
        return instance;
    }
}

这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执 行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。

**结论：**这种单例模式可用，但是可能造成内存浪费

懒汉式（线程不安全）

package 懒汉式;

/**
懒汉式方式一：线程不安全
 */
public class Singleton {
    //1.私有化构造器
    private Singleton(){}

    //2.声明Singleton类型的变量instance
    private static Singleton instance;//知识声明声明一个该类型的变量，并没有进行赋值

    //3.提供一个公共的访问方式，让外界获取该对象
    public static Singleton getInstance(){
        //判断为instance是否为null,如果为null，说明还没有创建Singleton类的对象
        //如果没有，创建一个并返回；如果有，直接返回
        if(instance == null){
            //不安全：多线程情况下，线程1等待，线程2获取到cpu的执行权，也会进入到该判断里面，那么此时创建的就不是单例对象（改进情况方式二）

            instance = new Singleton();
        }
        return instance;
    }
}

起到了 Lazy Loading 的效果，但是只能在单线程下使用。

如果在多线程下，一个线程进入了 if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过 了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式

**结论：**在实际开发中，不要使用这种方式.

懒汉式（线程安全）

package 懒汉式;

/**
 *懒汉式方式二：线程安全
 */
public class Singleton2 {
    //1.私有化构造器
    private Singleton2(){}

    //2.声明Singleton类型的变量instance
    private static Singleton2 instance;//知识声明声明一个该类型的变量，并没有进行赋值

    //3.提供一个公共的访问方式，让外界获取该对象
    public static synchronized Singleton2 getInstance(){
        //判断为instance是否为null,如果为null，说明还没有创建Singleton类的对象
        //如果没有，创建一个并返回；如果有，直接返回
        if(instance == null){
            //不安全：多线程情况下，线程1等待，线程2获取到cpu的执行权，也会进入到该判断里面，那么此时创建的就不是单例对象（改进情况方式二）
            //解决方式：给类上加锁，这样线程2获取cpu的执行权但是进不来，只能在外边等直到线程1执行完
            instance = new Singleton2();
        }
        return instance;
    }
}

解决了线程安全问题

效率太低了，每个线程在想获得类的实例时候，执行 getInstance()方法都要进行同步。而其实这个方法只执行 一次实例化代码就够了，后面的想获得该类实例，直接 return 就行了。方法进行同步效率太低

**结论：**在实际开发中，不推荐使用这种方式

懒汉式 (双重检查锁)

package 懒汉式;

/**
 懒汉式方式三：双重检查锁
 懒汉式加锁会导致性能低下，原因是对getInstance()方法来说，绝大部分的操作都是读操作，读操作是线程安全的，
 所以我们没必要让每个线程必须持有锁才能调用更改方法，因此我们需要调整加锁的时机。
 */
public class Singleton3 {
    //1.私有构造方法
    private Singleton3(){}
    //2.声明Sinleton类型的变量
    private static volatile Singleton3 instance;
        /*在多线程情况下，可能会出现空指针问题，原因是JVM在实例化对象的时候汇景轩优化和指令重排序操作，
        解决方案，只需要使用volatile关键字，volatile关键字可以保证可见性和有序性。*/
    //3.对外提供公共的访问方式
    public static Singleton3 getInstance(){
        //第一次判断,如果instance的值不为null,不需要抢占锁，直接返回对象（提升效率）
        if(instance == null){
            synchronized (Singleton3.class){
                //第二次判断
                if(instance == null){
                    instance = new Singleton3();
                }
            }
        }
        return instance;
    }
}

优点：-Check 概念是多线程开发中常使用到的，如代码中所示，我们进行了两次 if (singleton == null)检查，这 样就可以保证线程安全了。

这样，实例化代码只用执行一次，后面再次访问时，判断 if (singleton == null)，直接 return 实例化对象，也避免的反复进行方法同步.

线程安全；延迟加载；效率较高

**缺点：**在多线程情况下，可能会出现空指针问题，原因是JVM在实例化对象的时候汇景轩优化和指令重排序操作，解决方案，只需要使用volatile关键字，volatile关键字可以保证可见性和有序性。

**结论：**在实际开发中，推荐使用这种单例设计模式

懒汉式（静态内部类方法）

package 懒汉式;

/**
懒汉式方式四：静态内部类方法
 静态内部类单例模式汇总实例由内部类创建，由于JVM在加载外部类的过程中，是不会加载静态内部类的，只有内部类的属性/方法
 被调用时才会被加载，并初始化其静态属性。静态属性由于被static修饰，保证只被实例化一次，并且严格保证实例化顺序。
 */
public class Singleton4 {
    //1.私有化构造方法
    private Singleton4(){}
    //2.定义一个静态内部类
    private static class SingletonHolder {
        //在内部类中声明并初始化外部类的对象
        private static final Singleton4 INSTANCE = new Singleton4();//被final修饰即为常量，常量命名规范为大写instance=>INSTANCE
    }
    //3.提供公共的访问方式
    public static Singleton4 getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

第一次加载Singleton4类时不会去初始化INSTANCE，只有第一次调 getInstance，虚拟机加载SingletonHolder并初始化INSTANCE。这样不仅能确保线程安全，而且也能保证Singleton4类的唯一性。

优点：在没有加任何锁的情况下，保证了多线程的安全，并且没有任何性能影响和空间的浪费。

结论：推荐使用.

懒汉式（枚举方式）

package 懒汉式;

/**
 懒汉式方法五：枚举方式
 因为枚举类型是线程安全的，并且只会装载一次，设计者充分的利用了枚举的这个特性来实现单例模式。
 枚举类写法非常简单，而且枚举类型是不会被破坏的单例实现模式。
 */
public enum Singleton5 {
    INSIANCE;
}

单例模式在 JDK 应用的源码分析

单例模式在 JDK 应用的源码分析

1. 我们 JDK 中，java.lang.Runtime 就是经典的单例模式(饿汉式)

2. 代码分析+Debug 源码+代码说明

3. 

   应用

   package 应用;
   
   
   import java.io.IOException;
   import java.io.InputStream;
   
   public class RuntimeDemo {
       public static void main(String[] args) throws IOException {
           //获取Runtime类的对象
           Runtime runtime = Runtime.getRuntime();
           //2.调用runtime对象的方法exec,参数要的是一个命令
           Process process = runtime.exec(" ipconfig");
           //3.调用process对象的获取输入流的方法
           InputStream is = process.getInputStream();
           byte[] arr = new byte[1024*1024*100];
           //4.读取数据
           int len = is.read(arr);//返回读到的字节个数
           //5.将字节数组转换为字符串输出到控制台
           System.out.println(new String(arr,0,len,"GBK"));
       }
   }