设计模式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;
     }
 }

UserHunger_Safe.java

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;
     }
 }

UserLazy_Unsafe.java

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;
     }
 }

UserLazy_Safe.java

方法加锁，则每次调用都需要锁定，严重影响性能，这不是想要的。所以优化下得出第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;
     }
 }

UserDCL_Safe.java

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

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;
     }
 }

UserStaticInnerClass_Safe.java

至此，单例模式是不是绝对安全了？答案当然不是，在反射攻击下，外部依旧能做到非单例，不信，读者可以通过反射方式获得以上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 + '\'' +
                 '}';
     }
 }

UserEnum.java

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

测试

 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);
     }
 }

main方法

 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