java23种设计模式（一） 单例模式

        单例模式涉及到一个类，这个类只能创建单个对象。这个类提供了一种访问其唯一的对象的方法，可以直接访问，不需要实例化该类的对象。

        单例模式的实现：

1.饿汉式：类加载时创建该类的对象

2.懒汉式：类加载时不创建对象，首次使用该对象时才会创建。

（1） 饿汉式

        1）以下是静态变量的形式写的饿汉式单例，和测试代码。

package com.huangzhenhui.patten.singleton.demo1;

//饿汉式：静态成员变量
public class Singleton {
//    1.私有构造方法
    private Singleton(){}

//    2.在本类中创建对象
    private static Singleton instance = new Singleton();

//    3.提供一个公共的方法
    public static Singleton getInstance(){
        return instance;
    }
}

public class Client {
    public static void main(String[] args) {
//        创建Singleton类的对象
        Singleton instance = Singleton.getInstance();

        Singleton instance1 = Singleton.getInstance();


//        判断两个对象是否式同一个对象
        System.out.println(instance == instance1);
    }
}

结果如下：

        2）静态代码块的方式。

public class Singleton {

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

//    声明该类的对象
    private static Singleton instance;

//    在静态代码块中给对象赋值
    static {
        instance = new Singleton();
}
//    给出可以访问这个对象的方法
    public static Singleton getInstance(){
        return instance;
    }
}

 测试代码跟静态变量的测试代码是一样的。

public class Client {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        System.out.println(singleton1==singleton);
    }
}

 结果也是 true。说明两次获取到的对象是同一个，在Java中，如果是基本数据类型，则 == 比较的是值；如果是引用类型，则 == 比较的是对象的地址。两个对象的地址是一样的说明是同一个对象。

        饿汉式单例的对象是在类的加载时创建，假如不使用也一直存在，假如对象足够大，那就会造成内存的浪费。

所以有第二种，懒汉式，类加载时不会生成对象，只有使用的时候生成。

（2）懒汉式

1）用synchronized锁的方式。

package com.huangzhenhui.patten.singleton.demo3;

//懒汉式
public class Singleton {

//    首先私有化构造函数
    private Singleton() {
        System.out.println(Thread.currentThread().getName()+"ok");
    }

//    声明对象
    private static Singleton instance;

//    给出访问对象的方法,注意懒汉式是要使用对象的时候才生成。
    public static synchronized Singleton getInstance(){
//        判断对象是否已经创建，假如已经创建，直接返回，假如没有创建就先创建然后返回。
        if(instance==null){
            instance = new Singleton();
        }
        return  instance;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                Singleton.getInstance();
            }).start();
        }
    }
}

 但是这种方式每次都加锁，极大的影响性能。大部分都是读操作，所以这样不合理。

 2）第二种是双重检测锁模式。

//双重检测锁模式
public class Singleton {
//    第一步都是私有化构造方法
    private Singleton(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }
//    申明对象但是不赋值，等调用访问方法的时候再赋值，避免内存浪费
    private static Singleton instance;
//    访问对象的方法
    public static Singleton getInstance(){
        if(instance==null){
            synchronized (Singleton.class){
                if(instance==null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                Singleton.getInstance();
            }).start();
        }

    }
}

但是双重检测锁模式还是有问题，因为

instance = new Singleton()

new方法不是一个原子性操作。

new方法包含以下几步：

1，分配内存空间

2，执行构造方法，初始化对象

3，把这个对象指向这个空间

有可能会指令重排，132，123都有可能，所以要加在声明对象的时候加  volatile

//双重检测锁模式
public class Singleton {
//    第一步都是私有化构造方法
    private Singleton(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }
//    申明对象但是不赋值，等调用访问方法的时候再赋值，避免内存浪费
    private volatile static Singleton instance;
//    访问对象的方法
    public  static Singleton getInstance(){
        if(instance==null){
            synchronized (Singleton.class){
                if(instance==null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                Singleton.getInstance();
            }).start();
        }

    }
}

 3.静态内部类方式。

        静态内部类单例模式种实例由内部类创建，由于jvm在加载外部类的过程中，是不会加载静态内部 类的，只有内部类的属性、方法被调用时才会加载，并初始化其静态属性。静态属性由于被static修饰，保证只被实例化一次，并且严格保证实例化顺序。

//静态内部类单例模式
public class Singleton {
//    私有化构造方法
    private Singleton(){}
//    定义静态内部类
    private static class SingletonHolder{
//        在内部类中声明并初始化外部类的对象
        private static final Singleton INSTANCE = new Singleton();
}
//  访问对象的方法
    public static Singleton getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

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

总结：静态内部类单例模式是一种优秀的单例模式，是开源项目中比较常见的一种单例模式，在没有加任何锁的情况下，保证了多线程下的安全，并且没有任何性能影响和空间的浪费。

4） 枚举方式

//枚举方式
public enum Singleton {
    INSTANCE;
}

测试代码

public class Client {
    public static void main(String[] args) {
        Singleton singleton = Singleton.INSTANCE;
        Singleton singleton1 = Singleton.INSTANCE;
        System.out.println(singleton1==singleton1);
    }

}

 枚举类实现单例模式式非常好的，因为枚举类型式线程安全的并且只会装载一次。

 注意注意注意：枚举方式属于饿汉式方式，在不考虑浪费空间的情况下，可以首选枚举方式。