Java_设计模式之单例模式

单例模式

所谓的单例设计模式，采取一定方法保证软件系统当中，对某个类只能存在一个对象实例。
并且该类只提供一个获取对象实例的方法。

单例模式有八种方式实现：主要包括饿汉式与懒汉式。

饿汉式与懒汉式的区别：

通俗版：

饿汉：饿了，饥不择食，系统一运行就创建对象，不考虑太多的问题。

懒汉：就是懒，就是不想创建对象，即使运行创建对象，每走一步都要找各种理由、说一大堆的问题，要考虑什么多线程、安全，对象重复等问题。总之一句话：懒，就是不想创建。

---

专业版：

饿汗模式，在类加载的时候对象就已经new出来了，1.对内存的开销比较大。
2.这种方式也没有考虑到线程安全，可能同时存在多个对象。不建议这样使用。

懒汉模式，懒汉式是在第一次使用时才创建对象，在多线程环境中要考虑线程安全问题。
在单线程下面比较安全，在多线程下面就不一定安全了。

1.饿汉式（静态常量）代码：

package singleton;

public class Singleton1 {

    public static void main(String[] args) {
        // 测试
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println("instance1的哈希值：" + instance1.hashCode());
        System.out.println("instance2的哈希值：" + instance2.hashCode());
    }



}

// 饿汉式（静态变量）
class Singleton{

    // 1. 构造器私有化，外部能new
    private Singleton(){

    }

    // 2. 本内部创建对象实例
    private final static Singleton instance = new Singleton();

    // 3. 提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance(){
        return instance;
    }


}

运行结果：

2. 饿汉式（静态代码块）代码：

// 饿汉式（静态代码块）
class Singleton{

    // 1. 构造器私有化，外部能new
    private Singleton(){

    }

    // 2. 本内部创建对象实例
    private  static Singleton instance = new Singleton();

    static {
        instance = new Singleton();
    }

    // 3. 提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance(){

        return instance;
    }

}

3.懒汉式（线程不安全的）代码：

在实际开发当中不能用.
原因：确实起到了懒加载的效果，需要才new对象，但是这只是在单线程的情况下。
若是在多线程的情况下，很有可能多个线程会同时进入 if（singleton == null）判断语句的方法，就会创建多个实例对象。

package singleton2;

public class Singleton2 {

    public static void main(String[] args) {
        // 测试
        System.out.println("懒汉式1，线程不安全");
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println("instance1的哈希值：" + instance1.hashCode());
        System.out.println("instance2的哈希值：" + instance2.hashCode());
    }

}


class Singleton{

    private static Singleton instance;

    private Singleton(){}

    // 提供一个静态的公有方法，当使用该方法时，才会去创建instance
    // 即懒汉式
    public static Singleton getInstance(){
        if (instance == null){
            instance = new Singleton();
        }
        return instance;
    }


}

4.懒汉式（线程安全，同步方法）代码：

在实际开发当中不能用。
原因：加入同步处理的代码，确实解决了线程安全的问题，但是效率太低了。
（因为getInstance（）方法会经常调用，加锁之后每次调用都要同步，而这个代码只需要执行一次实例化代码就ok，所以就说这样做效率特别慢）

package singleton2;

public class Singleton2 {

    public static void main(String[] args) {
        // 测试
        System.out.println("懒汉式1，线程不安全");
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println("instance1的哈希值：" + instance1.hashCode());
        System.out.println("instance2的哈希值：" + instance2.hashCode());
    }

}




// 线程安全的，同步方法
class Singleton{

    private static Singleton instance;

    private Singleton(){}

    // 提供一个静态的公有方法，加入同步处理代码，加把锁，解决线程安全问题
    // 即懒汉式
    public static synchronized Singleton getInstance(){
        if (instance == null){
            instance = new Singleton();
        }
        return instance;
    }


}

5.懒汉式（线程安全，同步代码块）

更不靠谱了。
不靠谱的原因：（在创建对象的时候加锁，可是在判断的时候就又会造成线程不安全的问题）

// 线程安全的，同步代码块
class Singleton{

    private static Singleton instance;

    private Singleton(){}


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


}

6. 双重检查（线程安全，速度快，推荐）代码：

推荐使用。
原因：双层检查一是保证了线程安全，二是保证了效率。
（比如A.B两个线程同时进入第一个判断，然后还要在同步代码的时候进行二次判断。只需要同步一次，同步完成后，之后再进来的线程C,D,E都进不去了）

public class Singleton3 {

    public static void main(String[] args) {
        // 测试
        System.out.println("懒汉式-双重检查");
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println("instance1的哈希值：" + instance1.hashCode());
        System.out.println("instance2的哈希值：" + instance2.hashCode());
    }

}




// 懒汉式-双重检查
class Singleton{

    private static volatile Singleton instance;

    private Singleton(){}

    // 提供一个静态的公有方法，加入双重检查代码，解决线程安全问题，又解决懒加载问题
    // 同时保证了效率，推荐使用

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

}

关键字volatile作用：
简单来说，volatile让变量每次在线程当中被使用的时候，都从主存中取。而不是从各个线程的“工作内存”。

7.静态内部类（线程安全）代码：

推荐使用。
原因：
一是静态内部类，在singleton类被加载的时候不会立即被加载，而是在调用getInstance方法时，从而完成singleton的实例化。
二是因为，静态内部类在第一次初始化的时候，是JVM的类加载机制帮我们保证了线程安全，别的线程无法进入。

所以说保证了线程安全的同时，也利用了静态内部类的特点实现了延迟加载，效率高。

public class Singleton4 {

    public static void main(String[] args) {
        // 测试
        System.out.println("静态内部类");
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println("instance1的哈希值：" + instance1.hashCode());
        System.out.println("instance2的哈希值：" + instance2.hashCode());
    }

}


// 静态内部类
class Singleton{

    private static volatile Singleton instance;

    // 构造器私有化
    private Singleton(){}

    // 写一个静态内部类，该类只有一个静态属性Singleton
    private static class SingletonInstance{
        private static final Singleton INSTANCE = new Singleton();
    }


    public static synchronized Singleton getInstance(){
        return SingletonInstance.INSTANCE;
    }

}

8. 枚举（线程安全）代码：

推荐使用。
原因：枚举不仅可以保证线程安全，而且枚举还能防止反序列化重新创建新的对象。

public class Singleton5 {

    public static void main(String[] args) {
        // 测试
        System.out.println("枚举");
        Singleton instance1 = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance1 == instance2);
        System.out.println("instance1的哈希值：" + instance1.hashCode());
        System.out.println("instance2的哈希值：" + instance2.hashCode());

        instance1.sayOK();
    }

}


// 枚举
enum Singleton{
    INSTANCE;  // 属性
    public void sayOK(){
        System.out.println("OK~");
    }
}