标签：区别 div 私有化 net instance 单例对象 font system logs
最近学习了设计模式之单例模式，现在进行总结一下吧。
（1）饿汉模式：饿汉模式利用类的加载机制
好处：只在类的加载时候创建一次实例，不会存在多线程创建多个实例的问题，避免了多线程同步的问题。
缺点：即使这个实例没有被程序用到，也会被创建，内存就浪费了。
/** * 单例模式-饿汉模式 * @author szekinwin * */ public class SingleTon { private SingleTon(){};//私有化构造方法 private static SingleTon singleTon=new SingleTon(); //提供一个静态方法供外部获取对象 public static SingleTon getIntance(){ return singleTon; } public static void main(String []args){ //线程1 Thread t1=new Thread(new Runnable() { public void run() { System.out.println(SingleTon.getIntance().hashCode()); } },"t1"); //线程2 Thread t2=new Thread(new Runnable() { public void run() { System.out.println(SingleTon.getIntance().hashCode()); } },"t2"); t1.start(); t2.start(); } }
（2）懒汉模式：懒汉模式是需要的时候才去创建对象，如果实例已经被创建了，则返回之前创建的实例。
/** * 单例模式-懒汉模式 * @author szekinwin * */ public class SingleTon2 { private SingleTon2(){};//私有化构造方法 private static SingleTon2 singleTon=null; private static synchronized SingleTon2 getInstance(){ if(singleTon==null){ singleTon=new SingleTon2(); } return singleTon; } public static void main(String []args){ Thread t1=new Thread(new Runnable() { public void run() { System.out.println(SingleTon2.getInstance().hashCode()); } },"t1"); Thread t2=new Thread(new Runnable() { public void run() { System.out.println(SingleTon2.getInstance().hashCode()); } },"t2"); t1.start(); t2.start(); }
需要注意的是，懒汉模式需要在获取实例的方法加上同步锁synchronized。如果不加，则会出现创建多个实例的结果。例如当线程t1执行if(singleTon==null)时，t2线程获得CPU执行权，也执行了if(singleTon==null),创建了实例。这时，t1又获取了CPU执行权，由于之前执行判断了if(singleTon==null)为true（不会再次执行判断），则又创建了一个实例。
缺点：懒汉模式虽然实现了延迟加载，但是由于获取实例的方法加上了同步锁，所以当多线程同时去竞争锁的时候，非常影响性能，因此就有了双重校验锁。
（3）双重校验锁
/** * 单例模式-双重校验锁 * @author szekinwin * */ public class SingleTon3 { private SingleTon3(){};//私有化构造方法 private static volatile SingleTon3 singleTon=null; public static SingleTon3 getInstance(){ if(singleTon==null){//第一次校验 synchronized(SingleTon3.class){ if(singleTon==null){//第二次校验 singleTon=new SingleTon3(); } } } return singleTon; } public static void main(String[]args){ for(int i=0;i<200;i++){ new Thread(new Runnable() { public void run() { System.out.println(Thread.currentThread().getName()+":"+SingleTon3.getInstance().hashCode()); } }).start(); } } }
问题：为什么需要两次判断if(singleTon==null)?
分析：第一次校验：由于单例模式只需要创建一次实例，如果后面再次调用getInstance方法时，则直接返回之前创建的实例，因此大部分时间不需要执行同步方法里面的代码，大大提高了性能。如果不加第一次校验的话，那跟上面的懒汉模式没什么区别，每次都要去竞争锁。
第二次校验：如果没有第二次校验，假设线程t1执行了第一次校验后，判断为null，这时t2也获取了CPU执行权，也执行了第一次校验，判断也为null。接下来t2获得锁，创建实例。这时t1又获得CPU执行权，由于之前已经进行了第一次校验，结果为null（不会再次判断），获得锁后，直接创建实例。结果就会导致创建多个实例。所以需要在同步代码里面进行第二次校验，如果实例为空，则进行创建。
需要注意的是，private static volatile SingleTon3 singleTon=null;需要加volatile关键字，否则会出现错误。问题的原因在于JVM指令重排优化的存在。在某个线程创建单例对象时，在构造方法被调用之前，就为该对象分配了内存空间并将对象的字段设置为默认值。此时就可以将分配的内存地址赋值给instance字段了，然而该对象可能还没有初始化。若紧接着另外一个线程来调用getInstance，取到的就是状态不正确的对象，程序就会出错。
（4）静态内部类：同样也是利用了类的加载机制，它与饿汉模式不同的是，它是在内部类里面去创建对象实例。这样的话，只要应用中不使用内部类，JVM就不会去加载这个单例类，也就不会创建单例对象，从而实现懒汉式的延迟加载。也就是说这种方式可以同时保证延迟加载和线程安全。
/** * 单例模式-静态内部类 * @author szekinwin * */ public class SingleTon4 { private SingleTon4(){};//私有化构造方法 //静态内部类 private static class SingleTonHolder{ private static SingleTon4 singleTon=new SingleTon4(); } public static SingleTon4 getInstance(){ return SingleTonHolder.singleTon; } public static void main(String []args){ Thread t1=new Thread(new Runnable() { public void run() { System.out.println(SingleTon4.getInstance().hashCode()); } },"t1"); Thread t2=new Thread(new Runnable() { public void run() { System.out.println(SingleTon4.getInstance().hashCode()); } },"t12"); t1.start(); t2.start(); } }
参考网站：http://blog.csdn.net/goodlixueyong/article/details/51935526
标签：区别 div 私有化 net instance 单例对象 font system logs
原文地址：http://www.cnblogs.com/gdpuzxs/p/6682332.html
