Java设计模式(更新中。。。)

1、单例模式(Singleton)

• 如何实现单例？

  一般我们获取实例是直接通过new实现，原因是类中默认有无参构造方法。但是通过new来创建实例则可以创建多个实例，而单例模式是只创建一个实例。因此，我们设置构造方法私有化(private)这样其他类就不能直接通过构造方法创建该实例

• 应用场合

  在程序中有些对象它只需要一个就足够了，不需要创建多个对象(实例)时，可以使用单例模式，这样可以保证整个应用程序中有且只有一个该对象(实例)。如:日志文件，线程池，数据库连接池等。

1.1 饿汉式单例

• 什么是饿汉模式？

  当类加载的时候创建其唯一实例(你可以理解为太饿了马上就要吃饱，所以类一旦加载就马上创建实例)

• 代码：

/**
 * @program: soft_test
 * @description: 单例模式-饿汉式
 * @author: Mr.zuo
 * @create: 2021-02-17 22:18
 **/

public class HungrySingleton {
    /**
     * 1.将构造方法私有化
     * 目的:不允许外部类之间创建对象(new)
     * */
    private HungrySingleton(){
    }
    /**
     *2. 在单例类的内部创建对象，并且static话，
     * 目的: static后可以让该类加载后直接创建该类的实例对象
     * */
    private static HungrySingleton instance = new HungrySingleton();

    /**
     * 3.提供一个获取实例的方法
     * 目的: 给实例private后，为了让外部获取实例，提供一个public的方法供外部调用获取实例
     * */
    public static HungrySingleton getInstance(){
        return instance;
    }
}


//=======================================测试==================================================

/**
 * @program: soft_test
 * @description: 饿汉式单例测试
 * @author: Mr.zuo
 * @create: 2021-02-17 22:33
 **/

public class HungrySingletonTest {
    public static void main(String[] args) {
        HungrySingleton singleton1 = HungrySingleton.getInstance();
        HungrySingleton singleton2 = HungrySingleton.getInstance();
        if (singleton1 == singleton2){
            System.out.println("为同一个实例对象");// true
        }else {
            System.out.println("为不同实例对象");// false
        }
    }
}

• 特点

  1. 线程安全

  2. 类加载的同时会创建对象，此时相对懒汉式速度慢点，但是调用该对象的时候相对更快

1.2 懒汉式单例

• 什么是懒汉式单例？

  当类加载时不会立即创建该类的实例对象，当需要调用该对象时才会创建(你可以理解为我很懒；我有拖延症。我创建类的对象的时候并不想第一时间实例化，只有等到要用到的时候才实例化)

• 代码

  /**
 * @program: soft_test
 * @description: 单例模式之懒汉式
 * @author: Mr.zuo
 * @create: 2021-02-17 22:53
 **/

public class LazySingleton {
    /**
     * 1.将构造方法私有化，避免外界类直接创建对象
     * */
    private LazySingleton(){}

    /**
     * 2.使用private,static修饰,但是不会直接创建该实例
     * */
    private static LazySingleton instance;

    /**
     * 3.提供调用该实例的方法，当第一次获取该实例的时候，创建该实例,否则直接返回该实例
     * */
    public static LazySingleton getInstance(){
        if (instance == null){
            instance = new LazySingleton();
        }
        return instance;
    }
}

//=======================================测试==================================================

/**
 * @program: soft_test
 * @description: 懒汉式单例测试
 * @author: Mr.zuo
 * @create: 2021-02-17 22:58
 **/

public class LazySingletonTest {
    public static void main(String[] args) {
        LazySingleton singleton1 = LazySingleton.getInstance();
        LazySingleton singleton2 = LazySingleton.getInstance();
        if (singleton1 == singleton2){
            System.out.println("为同一实例");// true
        }else {
            System.out.println("为不同实例");// false
        }
    }
}

• 特点

  1、线程不安全

  2、加载类时速度相对饿汉式更快，但是调用该类时速度相对就慢点

1.3双重检查模式---推荐(最常用)

• 什么是双重检查模式？

  当外部类需要创建该类的实例时，最多需要进行双重检查。

• 为什么要进行双重检查？

  采用双重检查模式，既可以保证线程安全，又可以做到延迟初始化(即与懒汉模式一样)，同时性能方面得到优化

• 代码

/**
 * @program: soft_test
 * @description: 双重检查模式
 * @author: Mr.zuo
 * @create: 2021-02-17 23:11
 **/

public class DoubleCheckSingleton {

    /**
     * 构造方法私有化
     * */
    private DoubleCheckSingleton(){}

    /**
     * volatile修饰: 禁止指令重排
     * */
    private volatile static DoubleCheckSingleton instance;

    public static DoubleCheckSingleton getInstance(){
        //减少不要同步，优化性能
        if (instance == null){
            // 同步，保证线程安全
            synchronized (DoubleCheckSingleton.class){
                if (instance == null){
                    // 创建实例
                    instance = new DoubleCheckSingleton();
                }
            }
        }
        return instance;
    }
}

//=======================================测试==================================================

/**
 * @program: soft_test
 * @description: 双重检查单例模式测试
 * @author: Mr.zuo
 * @create: 2021-02-17 23:16
 **/

public class DoubleCheckSingletonTest {
    public static void main(String[] args) {
        DoubleCheckSingleton singleton1 = DoubleCheckSingleton.getInstance();
        DoubleCheckSingleton singleton2 = DoubleCheckSingleton.getInstance();
        if (singleton1 == singleton2){
            System.out.println("实例对象相同");// true
        }else {
            System.out.println("实例对象不同");//false
        }
    }
}

• 特点

  1、延迟初始化。和懒汉模式一致，只有在初次调用静态方法getSingleton，才会初始化signleton实例。

  2、性能优化。同步会造成性能下降，在同步前通过判读singleton是否初始化，减少不必要的同步开销。

  3、线程安全。同步创建Singleton对象，同时注意到静态变量singleton使用volatile修饰。

1.4静态内部类模式--推荐

• 什么是静态内部类模式？

  采用静态内部类的方法创建单例模式

• 为什么要使用静态内部类模式？

  代码简洁，保证线程安全，且延迟初始化

• 代码

/**
 * @program: soft_test
 * @description: 静态内部类模式
 * @author: Mr.zuo
 * @create: 2021-02-17 23:35
 **/

public class StaticSingleton {
    private StaticSingleton(){}
    public static StaticSingleton getInstance(){
        return Inner.instance;
    }
    public static class Inner{
        private static final StaticSingleton instance = new StaticSingleton();
    }
}

//=======================================测试==================================================//

/**
 * @program: soft_test
 * @description: 静态内部类模式测试
 * @author: Mr.zuo
 * @create: 2021-02-17 23:37
 **/

public class StaticSingletonTest {
    public static void main(String[] args) {
        StaticSingleton singleton1 = StaticSingleton.getInstance();
        StaticSingleton singleton2 = StaticSingleton.getInstance();
        if (singleton1 == singleton2){
            System.out.println("为同一实例");// true
        }else {
            System.out.println("为不同实例");// false
        }
    }
}

• 特点

  1、实现代码简洁。和双重检查单例对比，静态内部类单例实现代码真的是太简洁，又清晰明了。

  2、延迟初始化。调用getSingleton才初始化Singleton对象。

  3、线程安全。JVM在执行类的初始化阶段，会获得一个可以同步多个线程对同一个类的初始化的锁。

参考：

1、Java:单例模式我只推荐两种

2、单例模式的6种实现方式

3、单例模式面试问题