设计模式2

目录

1、创建型模式特点和分类

2、单例模式（Singleton Pattern）

2.1、单例介绍

2.2、单例模式特点：

2.3、代码演示—单例的实现有8种

（1）饿汉式（静态常量）

（2）饿汉式（静态代码块）

（3）懒汉式（线程不安全）

（4）懒汉式(线程安全，同步方法)

（5）懒汉式（线程安全，同步代码块）

（6）双重检查

（7）静态内部类

（8）枚举方式

2.4、单例再探究

①优点：

②缺点：

③适用场景：

2.5、Java应用

spring中的单例

---

1、创建型模式特点和分类

            关注的问题：如何创建对象，将对象的创建和使用分离，这样的目的可以降低代码的耦合度的问题。例如：spring中IOC容器管理对象。

单例模式、工厂模式、抽象工厂模式、建造者模式、原型模型

2、单例模式（Singleton Pattern）

2.1、单例介绍

单例模式（Singleton Pattern）：保证一个类只有一个实例，并提供一个访问它的公有的访问点。

单例类图：

单例中包含的角色：

单例类：包含一个实例且能自行创建这个实例类。

2.2、单例模式特点：

①单例类只有一个实例对象。

②单例对象必须由单例类自行创建。

③单例类对外提供一个可访问该单例的全局公有访问点。

2.3、代码演示—单例的实现有8种

①饿汉式（静态常量）两种

②饿汉式（静态代码块）两种

③懒汉式

④双重检查

⑤静态内部类

⑥枚举

（1）饿汉式（静态常量）

/**
 * 饿汉式（静态变量）
 * 线程安全的，在类加载到内存中后，由JVM保证线程安全
 * 简单，推荐实现
 */
public class Singleton1 {
    //构造函数私有化（防止new）
    private Singleton1() {}

    //本类内部创建对象,静态变量
    private  final static  Singleton1 single = new Singleton1();

    //提供一个公有的静态方法，返回实例对象，提供给外部使用
    public static Singleton1 getInstance() {
        return single;
    }
}

优缺点：

优点：写法简单，在类加载时已经完成类的实例化，保证线程安全。

缺点：在类加载时完成了实例化（没有实现懒加载），如果没有使用这个实例，会造成内存的浪费。

（2）饿汉式（静态代码块）

/**
 * 饿汉式(静态代码块)
 */
public class Singleton2 {
    //构造函数私有化
    private Singleton2(){}
    
    //类内部创建对象实例
    private static Singleton2 single;
    
    //在静态代码块中，创建单例对象
    static {
        single = new Singleton2();
    }
    
    //提供公有的访问点
    public static Singleton2 getInstance(){
        return single;
    }
}

优缺点和饿汉式静态变量一样。

（3）懒汉式（线程不安全）

/**
 * 懒汉式(线程不安全)
 */
public class Singleton3 {
    private static Singleton3 single;

    private Singleton3 (){}

    //提供一个静态的公有的访问，当调用时，才创建实例，即懒汉式
    public static Singleton3 getInstance() {
        if (single == null) {
            single = new Singleton3();
        }
        return single;
    }
    
}

优点：

实现了懒加载的效果，但是只能在单线程使用

缺点：

在多线程下，存在线程不安全

（4）懒汉式(线程安全，同步方法)

/**
 * 懒汉式
 */
public class Singleton4 {
    private static Singleton4 single;

    private Singleton4 (){}

    //提供一个静态的公有的访问，当调用时，才创建实例，即懒汉式
    public static synchronized Singleton4 getInstance() {
        if (single == null) {
            single = new Singleton4();
        }
        return single;
    }
}

线程安全的关键点：synchronized

优点：

通过线程安全的关键字，解决线程安全问题

缺点：

效率低下，每个线程在获取实例的时候，执行getInstance都需要进行同步，方法的同步效率太低

（5）懒汉式（线程安全，同步代码块）

/**
 * 懒汉式
 */
public class Singleton5 {
    private static Singleton5 single;

    private Singleton5() {
    }

    //提供一个静态的公有的访问，当调用时，才创建实例，即懒汉式
    public static Singleton5 getInstance() {
        if (single == null) {
            synchronized (Singleton5.class) {
                single = new Singleton5();
            }
        }
        return single;
    }
}

对加锁做了一定优化，总体优缺点和上面一致

（6）双重检查

/**
 * 双重检验
 */
public class Singleton6 {
    private static Singleton6 single;

    private Singleton6() {
    }

    //提供一个静态的公有的访问，当调用时，才创建实例，即懒汉式
    public static Singleton6 getInstance() {
        if (single == null) {
            synchronized (Singleton6.class) {
                if (single == null) {
                    single = new Singleton6();
                }
            }
        }
        return single;
    }
}

优缺点：

双重检查进行了两次的if (single == null)检查，保证线程安全性

线程安全，延时加载，效率高，推荐使用

（7）静态内部类

/**
 * 静态内部类
 * 静态内部属性 ，在类加载时进行初始化，保证线程安全
 * 采用静态内部类实现延迟加载
 */
public class Singleton7 {
    private Singleton7() {
    }
    
    //提供一个静态内部类，该类中有一个静态属性
    private static  class SingleHoler{
        private static final Singleton7 instance = new Singleton7();
    }

    //提供一个静态的公有的访问，直接返回SingleHoler.instance
    public static Singleton7 getInstance() {
        return SingleHoler.instance;
    }
}

优缺点：

线程安全：本质是通过类加载来保证线程安全

实现懒加载：只有在实际使用的时候，才会触发类的初始化，也是懒加载的一种形式

效率高：没有使用锁机制

推荐使用

（8）枚举方式

/**
 * 枚举方式实现单例
 */
public enum  Singleton8 {
    INSTANCE;//属性
    
    //提供一个静态的公有的访问，直接返回SingleHoler.instance
    public static Singleton8 getInstance() {
        return INSTANCE;
    }
}

推荐使用

2.4、单例再探究

①优点：

单例模式保证在内存中只存在一个实例，减少了内存的开销

避免了对资源的多种占用

单例设置全局访问点，可以优化和共享资源的访问

②缺点：

单例模式一般没有接口，扩展困难，如果要进行扩展，就需要修改代码，违背了开闭原则

③适用场景：

需要频繁创建的一些类，适用单例可以降低系统的内存压力，减少GC

某些对象实例占用资源比较多，或者实例耗时较长且经常使用的对象，采用单例形式

2.5、Java应用

spring中的单例

在spring中，Bean可以被定义两种模式：Singleton(单例)和Prototype（多例），Spring中模式采用的单例