设计模式-单例模式

Posted gdpuzxs

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了设计模式-单例模式相关的知识,希望对你有一定的参考价值。

  最近学习了设计模式之单例模式,现在进行总结一下吧。

  (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

 

    

  

以上是关于设计模式-单例模式的主要内容,如果未能解决你的问题,请参考以下文章

常用代码片段

性能比较好的单例写法

你熟悉的设计模式都有哪些?写出单例模式的实现代码

单例模式以及静态代码块

设计模式之单例模式

设计模式之单例模式