设计模式---单例模式

目录

1，概念

2，模型分类

3，单例模式的优缺点

4，创建单例模式

饿汉式

懒汉式

1，线程不安全

2，线程安全

---

1，概念

        单例模式，保证一个类仅仅有一个实例，并且提供一个访问它的全局访问点。

        让一个全局变量使其被一个对象访问，但是它不能防止实例化多个对象，让类自身负责保存它的唯一实例，同时这个类保证没有其他实例可以被创建，并且提供了一个访问该实例的方法。

        模型构成要求：

• 私有构造方法
• 私有静态引用指向自己的实例
• 以自己实例为返回值的共有静态方法

2，模型分类

饿汉式：类加载就会导致该单实例对象被创建

懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时被创建

3，单例模式的优缺点

优点：1，在内存只有一个实例，大大减少了内存的消耗，尤其是频繁的创建和销毁实例。

           2，避免对资源的多重占用

缺点：没有接口，不能继承，与单一职责冲突，一个类应该只关心内部逻辑，而不关心外面如何实例化。

4，创建单例模式

饿汉式

public class HungryChinese {
 
    //私有构造方法
    private HungryChinese(){}
 
    //在该类中创建一个该类的对象供外界去使用
    private static HungryChinese hungryChinese = new HungryChinese();
 
    //提供一个公共的访问方式，让外界获取hungryChinese对象
    public static HungryChinese getInstance(){
        return hungryChinese;
    }
}
class HungryChineseTest{
    public static void main(String[] args) {
        //获取单例类的对象，因为对象私有，只能通过方法去获取
        HungryChinese instance = HungryChinese.getInstance();
        HungryChinese instance1 = HungryChinese.getInstance();
        //判断是否为同一个对象
        System.out.println(instance.equals(instance1));
    }
}

问题：如果类加载对象时就被创建，一直在内存中，如果一直不使用，该对象存在，内存就浪费了。

懒汉式

1，线程不安全

public class LazyMan {
    //私有构造方法，为了不让外界创建该类的对象
    private LazyMan(){}
 
    //声明LazyMan类型的变量
    private static LazyMan instance;//只是声明了该类的对象，没有赋初始值
 
    //对外提供访问方式
    public static LazyMan getInstance(){
        //判断instance是否为null,如果为null,说明还没有创建LazyMan类的对象
        //如果没有，创建一个并返回；如果有，直接返回
        //线程不安全，多线程下会创建多个对象
        if (instance == null){
            instance = new LazyMan();
        }
            return instance;
    }
}
class LazyManTest{
    public static void main(String[] args) {
        LazyMan instance = LazyMan.getInstance();
        LazyMan instance1 = LazyMan.getInstance();
        System.out.println(instance.equals(instance1));
    }
}

2，线程安全

public class LazyMan2 {
    //私有构造方法，为了不让外界创建该类的对象
    private LazyMan2(){}
 
    //声明LazyMan类型的变量
    private static LazyMan2 instance;//只是声明了该类的对象，没有赋初始值
 
    //对外提供访问方式
    public static LazyMan2 getInstance(){
         //临界区互斥访问
        //先判断实例是否存在，不存在再进行加锁处理
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    //检查该单例是否已经被创建，保证单例模式
                    instance = new LazyMan2();
                }
            }
        }
            return instance;
    }
}
class LazyMan2Test{
    public static synchronized void main(String[] args) {
        LazyMan2 instance = LazyMan2.getInstance();
        LazyMan2 instance1 = LazyMan2.getInstance();
        System.out.println(instance.equals(instance1));
    }
}

优点 ：资源利用率高，不执行getInstance()就不被实例，可以执行该类其他静态方法 。
缺点 ：第一次加载时反应不快，由于java内存模型一些原因偶尔失败 。