设计模式 之 单例模式-02

 

最简单的 设计模式，还是先列出来吧。  写法多样，你知道几种呢？？？

单例模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

• 1、单例类只能有一个实例。
• 2、单例类必须自己创建自己的唯一实例。
• 3、单例类必须给所有其他对象提供这一实例。

 

不多说， 代码如下， 示例01

package com.yzgu.up.disignpattern.singleton;

/**
 *     单例模式三部曲
 *          私有化构造
 *          实例化对象，可以选择是否懒加载
 *          暴露公有方法，获取示例
 *
 *    @author yzgu
 */
public class SingleObject {

    //让构造函数为 private，这样该类就不会被实例化
    private SingleObject(){}

    //创建 SingleObject 的一个对象
    private static SingleObject instance = new SingleObject();

    //获取唯一可用的对象
    public static SingleObject getInstance(){
        return instance;
    }

    public void showMessage(){
        System.out.println("Hello World!");
    }
}

 

测试代码如下：

package com.yzgu.up.disignpattern.singleton;

/**
 * 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一
 *  特点：
 *      1、单例类只能有一个实例。
 *      2、单例类必须自己创建自己的唯一实例。
 *      3、单例类必须给所有其他对象提供这一实例。
 *   多种实现方式，可以参考 detail 中的写法， 根据实际情况选择。
 *    案例： 目前spring 的获取bean，类型scope 为singleton 时，是用了单例模式
 *                                    为prototype 时  用了原型模式
 * @author yzgu
 */
public class MainTest {

    public static void main(String[] args) {

        //不合法的构造函数
        //编译时错误：构造函数 SingleObject() 是不可见的
        //SingleObject object = new SingleObject();

        //获取唯一可用的对象
        SingleObject object = SingleObject.getInstance();

        //显示消息
        object.showMessage();
    }
}

 

下面，咱们来分析下，不同写法 线程安全问题。

 

示例02：

package com.yzgu.up.disignpattern.singleton.detail;

/**
 *   懒汉式，线程不安全
 *      懒加载模式
 *   @author yzgu
 */
public class Singleton1 {
    private static Singleton1 instance;
    private Singleton1 (){}

    public static Singleton1 getInstance() {
        if (instance == null) {
            instance = new Singleton1();
        }
        return instance;
    }
}

 

示例03：

package com.yzgu.up.disignpattern.singleton.detail;

/**
 *  懒汉式
 *      线程安全，基于同步阻塞关键字synchronized，多线程情况下会影响效率
 *      懒加载模式
 *       @author yzgu
 */
public class Singleton2 {

    private static Singleton2 instance;
    private Singleton2 (){}
    public static synchronized Singleton2 getInstance() {
        if (instance == null) {
            instance = new Singleton2();
        }
        return instance;
    }
}

 

 

示例04：

package com.yzgu.up.disignpattern.singleton.detail;

/**
 *  饿汉式：
 *      线程安全
 *      非懒加载模式
 *      特点：
 *          没有加锁，执行效率会提高
 *          类加载时就初始化，浪费内存。
 *          这种方式比较常用，但容易产生垃圾对象。
 *    @author yzgu
 */
public class Singleton3 {
    private Singleton3 (){}
    private static Singleton3 instance = new Singleton3();
    public static Singleton3 getInstance() {
        return instance;
    }
}

 

 

示例05 ，推荐使用

package com.yzgu.up.disignpattern.singleton.detail;

/**
 * 双检锁/双重校验锁（DCL，即 double-checked locking）
 *  这种方式采用双锁机制，安全且在多线程情况下能保持高性能。 getInstance() 的性能对应用程序很关键。
 *   懒加载模式
 *   线程安全
 *      推荐使用
 *   @author yzgu
 */
public class Singleton4 {
    private volatile static Singleton4 singleton;
    private Singleton4 (){}

    public static Singleton4 Singleton4() {
        if (singleton == null) {
            synchronized (Singleton4.class) {
                if (singleton == null) {
                    singleton = new Singleton4();
                }
            }
        }
        return singleton;
    }

}

好了，单例模式， 你学废了吗？？？

上面文章，装饰者模式