21.单例模式

package simpleMode;/* * 单利模式： * 保证一个类仅有一个实例，并提供一个访问他的全局访问点 *  * 通常我们可以让一个全局变量使得一个对象被访问，但它不能防止你实例化多个对象， * 一个最好的方法就是让类自身保存他的对象实例，这个类可以保证没有其他实例被创建， * 并且他可以提供一个访问该实例的方法 *  */ public class SimpleMode {public static void main(String[] args) {/*//懒汉式  模拟线程不安全   new Thread(){         public void run() {         System.out.println("线程不安全："+Singleton1.getInstance().hashCode());         }   }.start() ;   new Thread(){         public void run() {         System.out.println("线程不安全："+Singleton1.getInstance().hashCode());         }   }.start() ;   //2次的hashCode不一样 说明创建了2个实例   这就是2个线程同时进入了 if (instance == null)   //所以导致了问题的出现  第一个线程判断为空之后创建一个实例 第二个线程如果后进去的话 是不为空的 但是   //他是和第一个线程一起进入到if (instance == null) 的  在他进入的时候 判断为空是true         //懒汉式 线程安全   //可以看到 线程安全打印出来的hashCode是相同的   //为什么线程安全呢？   //因为在getInstance方法上加了一个synchronized修饰符 多个线程不能同时访问次方法   //第二个线程要等第一个线程访问完 这个方法之后才能访问这个方法 这个时候instance就不是null了 所以就不会重新new 对象了   //这种方式很少用  因为synchronized 是程序的瓶颈     new Thread(){         public void run() {         System.out.println("线程安全："+Singleton2.getInstance().hashCode());         }   }.start() ;   new Thread(){         public void run() {         System.out.println("线程安全："+Singleton2.getInstance().hashCode());         }   }.start() ;*/   //饿汉模式测试   2次输出是一样的/*System.out.println( Singleton3.getInstance().hashCode());System.out.println( Singleton3.getInstance().hashCode());*/   //枚举类型测试/*System.out.println(Singleton6.INSTANCE.getInstance().hashCode());System.out.println(Singleton6.INSTANCE.getInstance().hashCode());*/}}/* * 懒汉，线程不安全  * 懒汉式的特点是延迟加载，比如配置文件，采用懒汉式的方法，顾名思义，懒汉么，很懒的，配置文件的实例直到用到的 */class Singleton1 {      private static Singleton1 instance;      private Singleton1 (){}      public static Singleton1 getInstance() {      if (instance == null) {      //为了达到效果 这里sleep2秒 在高并发的情况下 try {Thread.sleep(2000);} catch (InterruptedException e) {}        instance = new Singleton1();      }      return instance;      }     }  /* * 懒汉，线程安全  */class Singleton2{      private static Singleton2 instance;      private Singleton2 (){}      public synchronized static Singleton2 getInstance() {      if (instance == null) {      //为了达到效果 这里sleep2秒 在高并发的情况下 try {Thread.sleep(2000);} catch (InterruptedException e) {}        instance = new Singleton2();      }      return instance;      }     }  /**饿汉式：*饿汉式的特点是一开始就加载了，*如果说懒汉式是“时间换空间”，那么饿汉式就是“空间换时间”，因为一开始就创建了实例，所以每次用到的之后直接返回就好了*这种方式基于classloder机制避免了多线程的同步问题，*不过，instance在类装载时就实例化，虽然导致类装载的原因有很多种，*在单例模式中大多数都是调用getInstance方法，* 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，* 这时候初始化instance显然没有达到lazy loading的效果。*/ class Singleton3 {      private static Singleton3 instance = new Singleton3();      private Singleton3 (){    System.out.println("11111111111");    }      public static Singleton3 getInstance() {      return instance;      }  }   /*  * 饿汉式 换汤不换药 跟上边一样  */ class Singleton4 {      private  static  Singleton4 instance = null;      static {      instance = new Singleton4();      }      private Singleton4 (){}      public static Singleton4 getInstance() {      return instance;    }  }     /* *静态内部类 *这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程， *它跟第三种和第四种方式不同的是（很细微的差别）：第三种和第四种方式是只要Singleton类被装载了， *那么instance就会被实例化（没有达到lazy loading效果）， *而这种方式是Singleton类被装载了，instance不一定被初始化。 *因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时， *才会显示装载SingletonHolder类，从而实例化instance。 *想象一下，如果实例化instance很消耗资源，我想让他延迟加载， *另外一方面，我不希望在Singleton类加载时就实例化，因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载， *那么这个时候实例化instance显然是不合适的。这个时候，这种方式相比第三和第四种方式就显得很合理。 */ class Singleton5 {      private static class SingletonHolder {      private static final Singleton5 INSTANCE = new Singleton5();      }      private Singleton5 (){}      public static final Singleton5 getInstance() {      return SingletonHolder.INSTANCE;      }  }   /* * 枚举模式 * 建议先看看关于枚举的相关知识 * 首先，在枚举中我们明确了构造方法限制为私有，在我们访问枚举实例时会执行构造方法， * 同时每个枚举实例都是static final类型的，也就表明只能被实例化一次。 * 在调用构造方法时，我们的单例被实例化。   * 也就是说，因为enum中的实例被保证只会被实例化一次，所以我们的INSTANCE也被保证实例化一次。  * 可以看到，枚举实现单例还是比较简单的， *  *  *  《Effective Java》作者比较推崇这种做法  他说：单元素的枚举类型已经成为实现Singleton的最佳方法。 */  enum Singleton6 {      INSTANCE;      private Singleton77 instance;    Singleton6(){      instance = new Singleton77();    }      public Singleton77 getInstance() {        return instance;    }}   class Singleton77{  }   /*  * 双重校验  * 这个是第二种方式的升级版，俗称双重检查锁定  * 这种方式使用比较多  * volatile关键字 可以查阅相关资料：  * 对于volatile修饰的变量，jvm虚拟机只是保证从主内存加载到线程工作内存的值是最新的   * 例如假如线程1，线程2 在进行read,load 操作中，发现主内存中count的值都是5， 那么都会加载这个最新的值  * 在线程1对count进行修改之后，会write到主内存中，主内存中的count变量就会变为6  * 线程2由于已经进行read,load操作，在进行运算之后，也会更新主内存count的变量值为6  * 导致两个线程及时用volatile关键字修改之后，还是会存在并发的情况。  */  class Singleton8 {      private volatile static Singleton8 singleton;      private Singleton8 (){}      public static Singleton8 getSingleton() {      //这里可能同时有2个线程进入     if (singleton == null) {      //如果有多个线程进入 这里就会阻塞 但是这里基本没有线程进来 因为第一次初始化之后就不会进这里了        synchronized (Singleton8.class) {          if (singleton == null) {              singleton = new Singleton8();          }          }      }      return singleton;      }  }    //SimpleMode.java    /*  *枚举相关知识 这里有一个连接 http://blog.csdn.net/qq_36291682/article/details/73824339 讲的凑合  */