详解单例模式

Posted 2021-02-17 mzcc

关于单例模式，话不多说，即程序运行时无论New了多少次，即内存中只有一个实例对象。即对象的HasHCode一致。

单例模式的两大类

1、饿汉模式（即加载时就创建对象）

　　-1、直接实例化饿汉模式

　　-2、静态代码块饿汉模式（即需要加载初始化配置的时候适用）

　　-3、枚举方式

2、懒汉式（延迟加载）

　　-1、单线程安全下的懒汉

　　-2、多线程安全下的懒汉

　　-3、静态内部类的懒汉（安全）

　　

---

　　1、直接实例化饿汉模式

　　

package com.single;

public class Singleton {
   
    private static final Singleton SI=new Singleton();

    private Singleton(){

    }

    public static Singleton getsingleton(){
        return SI;
    }
}

 

　　单例模式必须保证自行创建，并且内部提供一个静态变量来保存这个唯一的对象，构造器私有化，即其他类内部中无法直接New当前的单例类，还需要提供一个对外获取实例的方法

　　当前模式在加载类的字节码的时候当前类的实例就立即会被创建

 

　　2、静态代码块饿汉模式（即需要加载初始化配置的时候适用）

　　

 1 public class Singleton2 {
 2 
 3     private static final Singleton2 SI;
 4 
 5     private String name;
 6     static {
 7         Properties properties=new Properties();
 8         try {
 9      
10             properties.load(Singleton2.class.getClassLoader().getResourceAsStream("db.properties"));
11             String name = properties.getProperty("name");
12             SI=new Singleton2(name);
13         } catch (IOException e) {
14             throw new RuntimeException(e);
15         }
16 
17     }
18 
19     private Singleton2(String name){
20         this.name=name;
21     }
22 
23     public static Singleton2 getsingleton(){
24         return SI;
25     }

　当我们需要在类创建的时候初始化参数，并且加载某些配置文件的时候可以使用 静态代码块的方式，在创建实例的时候通过构造器来完成相关参数的初始化。

　3.枚举方式的单例，自JDK1.5之后，首先枚举类和普通类的区别是什么？

使用enum定义的枚举类默认继承了java.lang.Enum类

枚举类的构造器只能使用private

枚举类的每个实例必须在枚举类中显示的列出（,分隔   ；结尾） 列出的实例系统会自动添加public static final修饰

所有的枚举类都定义了一个values方法，该方法可以很方便的遍历所有的枚举值

可以在switch表达式使用枚举类对象作为表达式，case子句可以直接使用枚举的名字，无需添加枚举类作为限定

枚举类对象的属性不能更改，所以要用private final修饰

枚举类对象要在构造器中被赋值
---------------------
作者：weirdowang
来源：CSDN
原文：https://blog.csdn.net/weirdowang/article/details/79970673

package com.single;
/*
枚举方式的单例
 */
public enum SingEnum {
    SING;
    SingEnum(){

    }
    public void info(){
        System.out.println("显示");
    }
}

　　是不是很简洁呢？ 确实如此，单例模式下 枚举方式的单例是最简洁的

　　二、懒汉模式

 

---

　　1、单线程安全下的懒汉

　　

package com.single2;
/*
    懒汉模式
 */
public class Singleton {
    private static Singleton singleton;

    private Singleton(){
        System.out.println("创建");
    }

    public static Singleton getSingleton(){
        if (singleton==null){
            singleton=new Singleton();
        }
        return singleton;
    }


}

 

　　我们可以看出无论怎么样，当前的懒汉都是在调用的时候才被加载创建的，但是它只是在单线程的情况下是安全的为什么呢？ 现在有一个需求即多个线程对这个 单例进行访问构建对象，在构建对象的时候使当前线程短暂的休眠一下

package com.single2;
/*
    懒汉模式测试线程不安全
 */
public class Singleton2 {
    private static Singleton2 singleton;

    private Singleton2(){
        System.out.println("创建");
    }

    public static Singleton2 getSingleton() throws InterruptedException {
        if (singleton==null){
            Thread.sleep(100);
            singleton=new Singleton2();
        }
        return singleton;
    }


}

测试代码如下：

　　

  /*
    懒汉模式下的多线程不安全
     */
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                Singleton2 singleton1 = Singleton2.getSingleton();
                System.out.println(singleton1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Singleton2 singleton2 = Singleton2.getSingleton();
                    System.out.println(singleton2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();
        thread2.start();
    }

　　经过测试，多线程情况下这种是不安全的 为什么呢？  第一个线程进入 进去之后， 线程休眠100ms 在此期间，第二个线程也开始进去到了创建的方法，由于当前第一个线程正在休眠，所以当前单例为null ，然后第一个线程休眠结束，创建第一个对象，此后第二个线程还在if中，也相继创建对象，此时便构造成了线程不安全的懒汉单例

　　2、线程安全的懒汉单例（双端检索）

package com.single2;

/*
懒汉模式 双端检索，避免了多次线程等待
 */
public class Singleton4 {
    private static Singleton4 singleton4;

    private Singleton4() {

    }

    public static Singleton4 getSingleton4() {
        if (singleton4 == null) {
            synchronized (Singleton4.class) {
                if (singleton4 == null) {
                    try {
                        Thread.sleep(100);

                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    singleton4 = new Singleton4();
                }
            }
        }
        return singleton4;
    }

}

使用synchronized 保证当前只能有一个线程进入 ，并且在外再次进行判断 若当前的单例已经被创建过了，避免了再次加锁，直接返回 
3、静态内部类的懒汉单例：（线程安全的）

package com.single2;

public class Singleton5 {
    private Singleton5(){

    }

    private static class demo{
        private static final Singleton5 SINGLETON_5=new Singleton5();
    }

    public static Singleton5 singleton5(){
        return demo.SINGLETON_5;
    }


}

也是懒汉模式最简单的单例实现，静态内部类不会随着外部类的初始化而初始化，并且内部类具有自己的类加载器，是安全的

如上便是单例模式的六种创建方式，欢迎大牛指正，源码放到群里了  另外也欢迎各位朋友们一起学习交流， qq群：956809929