设计模式Design Pattern(2)--单例模式

单例顾名思义就是一个实例。类只有唯一一个实例，并提供给全局使用。解决了全局使用的类频繁地创建与销毁带了的消耗。

单例模式常用简单，但细究却又不简单，且往下看。

单例模式又可以分为

（1）懒汉式：需要使用实例时，才创建实例

（2）饿汉式：类加载时，就创建静态实例。

上代码

1、饿汉式,线程安全

/**
 * 饿汉式--线程安全
 * 优点：没有加锁，执行效率会提高。
 * 缺点：类加载时就初始化，浪费内存。
 */
public class UserHunger_Safe {
    /**
     * 对象实例
     */
    private static UserHunger_Safe instance = new UserHunger_Safe();

    /**
     * 私有构造函数
     */
    private UserHunger_Safe() {
    }

    /**
     * 对外提供公共获取实例方法（线程安全）
     *
     * @return
     */
    public static UserHunger_Safe getInstance() {
        return instance;
    }
}

2、懒汉式，线程不安全

/**
 * 懒汉式单例模式
 * 线程不安全
 */
public class UserLazy_Unsafe {

    /**
     * 私有构造方法
     */
    private UserLazy_Unsafe() {
    }

    /**
     * 对象实例
     */
    private static UserLazy_Unsafe instance;

    /**
     * 对外提供公共获取实例方法（线程不安全）
     *
     * @return
     */
    public static UserLazy_Unsafe getInstance() {
        if (instance == null) {
            instance = new UserLazy_Unsafe();
        }
        return instance;
    }
}

3、懒汉式--方法加锁synchronized，线程安全 

/**
 * 懒汉式单例模式
 * 优点：第一次调用才初始化，避免内存浪费。
 * 缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。
 */
public class UserLazy_Safe {
    /**
     * 私有构造方法
     */
    private UserLazy_Safe() {
    }

    /**
     * 对象实例
     */
    private static UserLazy_Safe instance;

    /**
     * 对外提供公共获取实例方法（线程安全）
     *
     * @return
     */
    public static synchronized  UserLazy_Safe getInstance() {
        if (instance == null) {
            instance = new UserLazy_Safe();
        }
        return instance;
    }
}

方法加锁，则每次调用都需要锁定，严重影响性能，这不是想要的。所以优化下得出第4中方案

4、双重校验锁（DCL，即 double-checked locking）

/**
 * 饿汉式+双重校验锁
 */
public class UserDCL_Safe {
    /**
     * 对象实例
     */
    private static UserDCL_Safe instance;

    /**
     * 私有构造函数
     */
    private UserDCL_Safe() {
    }

    /**
     * 对外提供公共获取实例方法（线程安全）
     *
     * @return
     */
    public static synchronized UserDCL_Safe getInstance() {
        if (instance == null) {
            //双重校验锁
            synchronized (UserDCL_Safe.class) {
                if (instance == null) {
                    instance = new UserDCL_Safe();
                }
            }
        }
        return instance;
    }
}

如此一来，即便是多线程也能保证安全。如果只考虑静态域还可以使用内部静态类

5、静态内部类

/**
 * 登记式/静态内部类
 * 线程安全
 * 这种方式能达到双检锁方式一样的功效，但实现更简单。
 * 这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。
 */
public class UserStaticInnerClass_Safe {
    private static class SingletonHolder{
        private static final UserStaticInnerClass_Safe INSTANCE=new UserStaticInnerClass_Safe();//实例
    }

    //私有构造函数
    private UserStaticInnerClass_Safe(){}
    public  static final UserStaticInnerClass_Safe getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

至此，单例模式是不是绝对安全了？答案当然不是，在反射攻击下，外部依旧能做到非单例，不信，读者可以通过反射方式获得以上1,3,4,5例子的实例，就会发现依旧可以得到不同的实例。那有什么好的解决方案呢？

这个Effective Java 作者 Josh Bloch 大神给出了解决方案--使用枚举

6、枚举，最佳实现方式

/**
 * 枚举方式实现单例模式
 */
public enum UserEnum {
    INSTANCE;

    /**
     * 姓名
     */
    private String name;

    /**
     * 年龄
     */
    private int age;

    /**
     * 手机号码
     */
    private String telephone;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getTelephone() {
        return telephone;
    }

    public void setTelephone(String telephone) {
        this.telephone = telephone;
    }

    @Override
    public String toString() {
        return "SingletonPattern_EnumType{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", telephone='" + telephone + '\'' +
                '}';
    }
}

如此一来既保证了线程安全，也保证了反序列化安全

测试

import java.lang.reflect.Constructor;

public class SigletonPattern {
    public static void main(String[] args) throws Exception {
        //懒汉式单例--线程不安全
        UserLazy_Unsafe ul1 = UserLazy_Unsafe.getInstance();
        UserLazy_Unsafe ul2 = UserLazy_Unsafe.getInstance();
        System.out.println(ul1 + "\n" + ul2);
        System.out.println("===========懒汉式单例--线程不安全 End==========");

        //懒汉式单例--线程安全.获取实例方法添加synchronized,加锁会影响效率。
        UserLazy_Safe uls1 = UserLazy_Safe.getInstance();
        UserLazy_Safe uls2 = UserLazy_Safe.getInstance();
        System.out.println(uls1 + "\n" + uls2);
        System.out.println("===========懒汉式单例--线程安全 End==========");

        //懒汉式单例--登记式/静态内部类--线程安全。
        UserStaticInnerClass_Safe usic = UserStaticInnerClass_Safe.getInstance();
        UserStaticInnerClass_Safe usic2 = UserStaticInnerClass_Safe.getInstance();
        System.out.println(usic + "\n" + usic2);
        System.out.println("===========懒汉式单例--登记式/静态内部类--线程安全 End==========");

        UserEnum user = UserEnum.INSTANCE;
        //UserEnum user = new UserEnum();
        user.setName("科技无国界");
        user.setAge(0);
        user.setTelephone("16895965423");

        UserEnum levon = UserEnum.INSTANCE;
        //UserEnum levon = new UserEnum();
        levon.setName("联想--科技无国界");
        levon.setAge(10);
        levon.setTelephone("26895965423");

        System.out.println(user);
        System.out.println(levon);

        //通过反射获得对象
        Constructor<UserEnum> constructor = UserEnum.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        UserEnum sp = constructor.newInstance();
        System.out.println(sp);
    }
}

UserLazy_Unsafe@1b6d3586
UserLazy_Unsafe@1b6d3586
===========懒汉式单例--线程不安全 End==========
UserLazy_Safe@4554617c
UserLazy_Safe@4554617c
===========懒汉式单例--线程安全 End==========
UserStaticInnerClass_Safe@74a14482
UserStaticInnerClass_Safe@74a14482
===========懒汉式单例--登记式/静态内部类--线程安全 End==========
SingletonPattern_EnumType{name='联想--科技无国界', age=10, telephone='26895965423'}
SingletonPattern_EnumType{name='联想--科技无国界', age=10, telephone='26895965423'}
Exception in thread "main" java.lang.NoSuchMethodException: UserEnum.<init>()
    at java.lang.Class.getConstructor0(Class.java:3082)
    at java.lang.Class.getDeclaredConstructor(Class.java:2178)
    at SigletonPattern.main(SigletonPattern.java:39)

 示例源码：https://github.com/LF20160912/pattern