单例模式，额，单身啥

单例模式，是常见的设计模式之一，一般来说，是程序员较早接触的模式之一。嘻嘻，包括我~~~

 

一般来说，分两种：

• 饿汉模式。非常饿嘛，一上来就加载了，所以，就是非延迟加载的单例模式了。
• 懒汉模式。非常懒嘛，能不加载就不加载了，所以，是延迟加载的单例模式。

写一个单例虽然简单，有几点需要注意：

1. 取得单例的方法（这里为getInstance）是公开、静态的，不然难道要实例化类后，再从此方法获取单例？
2. 单例对象也是静态的，可供getInstance方法访问，同时也维持唯一性嘛
3. 构造方法是私有的，防止其他类任意实例化

 

来点解渴滴。。。

饿汉单例模式（非延迟加载）

package com.nicchagil.sample.designpattern.No01单例模式.No01非延迟加载模式;



public class Singleton {

    

    /*

     * 1.取得单例的方法（这里为getInstance）是公开、静态的，不然难道要调用类实例化后再从此方法获取单例？

     * 2.单例对象也是静态的，可供getInstance方法访问

     * 3.构造方法是私有的，防止其他类任意实例化

     */

    static Singleton s = new Singleton();

    

    private Singleton() {

        

    }

    

    public static Singleton getInstance() {

        return s;

    }

    

}

View Code

 

普通的懒汉单例模式（即延迟加载），用synchronized控制方法同步，避免线程并发生成多个对象。

比如：

• A线程判断为对象为空，进入方法体准备实例化对象，但又还没实例化对象，那一个Moment
• B线程也进行判断对象是否为空，结果当然为空，从而也进入方法体，准备实例化对象，这样就生成了两个不同的对象了，悲催了，哈哈哈哈哈

package com.nicchagil.sample.designpattern.No01单例模式.No02延迟加载模式;



public class Singleton {

    

    static Singleton s = null;

    

    private Singleton() {

        

    }

    

    public synchronized static Singleton getInstance() {

        if (s == null) {

            s = new Singleton();

        }

        

        return s;

    }

    

}

View Code

 

当然，为了效果好一些，可以使用synchronized同步块，从而避免整个方法都同步（毕竟在具体实现中，有些代码不需要同步嘛）

 

看了程杰老师的《大话设计模式》，里面巧妙使用了双重判断，再使用synchronized同步块，效率更高，高在哪？

如果没用双重判断，即把外层的判空剥去，每次取实例时都进入同步块，用美女的话来说，多费劲啊！！

双重判断，避免了每次获取实例进入同步块的问题，也解决了并发获取对象的问题：

• A线程判空后，进入方法体，但还没实例化对象，这时到了B线程
• B线程判空后，发现也为空，当然也进入方法体
• 这时，A、B俩都得排队进入同步块了
• 加入B进入并执行同步块的代码，实例化了单例的对象
• 轮到A进入同步快，在进行第二次判断，这时，哈哈哈哈哈

用JAVA实现分享下：

package com.nicchagil.sample.designpattern.No01单例模式.No04延迟加载模式_双重判断;



public class Singleton {

    

    static Singleton s = null;

    static Object o = new Object();

    

    private Singleton() {

        

    }

    

    public static Singleton getInstance() {

        /*

         * 在获取实例方法中使用设置同步，是为了避免在一线程判断为空后准备实例化单例对象但又还未实例化时，另一线程进行判空后发现单例对象为空进而实例化对象，从而使单例对象并非所指同一对象

         * 之所以用双重判断，然后在第一层判断后在嵌套同步块，

         * 因为如果每次欲获取单例，都使用同步机制，不仅效率较低，且系统消耗也较大

         * 所以，如单例对象已实例化，则无欲进入同步块以实例化单例对象

         */

        

        if (s == null) {

            synchronized (o) {

                if (s == null) {

                    s = new Singleton();

                }

            }

        }

        

        return s;

    }

    

}

View Code