常见设计模式之单例模式

单例模式

单例模式是一种常用的软件设计模式，主要目的是确保一个类在整个应用程序生命周期中只有一个实例，并提供一个全局访问点以获取该实例。

单例模式分为几种不同的实现方式，包括懒汉模式和饿汉模式。每种方式都有其特点和适用场景。例如，懒汉式单例在需要时才创建实例，而饿汉式单例则在类加载时立即创建实例。

懒汉模式

懒汉模式是一种单例模式的实现方式，它的特点是在首次访问单例对象时才进行对象的实例化。懒汉模式的优点是可以避免在程序启动时就进行对象的实例化，节省了系统的资源。懒汉模式的缺点是在多线程环境下，可能会出现线程安全问题，需要额外的同步措施来保证线程安全性。

例如如下：创建一个最简单的懒汉模式

// 单例模式
// 懒汉式 ：要的时候才创建出来
public class Singleton1 {
    private static Singleton1 singleton1 ;
    // 构造方法要私有化
    private Singleton1() {
    }
    public static Singleton1 getSingleton1(){
        if(singleton1 ==null){
            singleton1 = new Singleton1();
        }
        return singleton1;
    }
}

饿汉模式

饿汉模式是一种单例模式的实现方式，它的特点是在程序启动时就进行对象的实例化。在这种实现方式中，单例对象会在类加载时就被创建出来，因此也被称作“饱汉模式”或者“静态常量方式”。

饿汉模式的优点是实现简单、线程安全，无需考虑多线程环境下的同步问题。其缺点是无法进行懒加载，带来了一定的系统资源开销。在某些场景下，如果单例对象很大或者初始化耗时较长，饿汉模式的开销可能会比较明显。

例如:如下是一个最简单的饿汉模式

// 单例模式
// 饿汉式
public class Singleton2 {
    private final static Singleton2 singleton2 =new Singleton2();
    // 构造方法要私有化
    private Singleton2() {
    }
    public static Singleton2 getSingleton2(){
        return singleton2;
    }
}

创建线程安全的单例模式的几种方式

1.通过全局锁实现线程安全的单例模式（最简单，不建议使用）

public class Singleton3 {
    private  static Singleton3 singleton3;
    // 构造方法要私有化
    private Singleton3() {
    }
    public static synchronized Singleton3 getSingleton3(){
        if(singleton3 ==null) {
            Singleton3 singleton3 = new Singleton3();
        }        return singleton3;
    }
}

2.通过static静态代码块来实现线程安全（静态代码块只执行一次）

public class Singleton4 {
    private  static Singleton4 singleton4;
    static {
        singleton4 = new Singleton4();
    }
    // 构造方法要私有化
    private Singleton4() {
    }
    public static synchronized Singleton4 getSingleton4(){
      return singleton4;
    }
}

3.双重校验锁实现 ，经过双重判断来保证线程安全

public class Singleton5 {
    private static Singleton5 singleton5 ;
    // 构造方法要私有化
    private Singleton5() {
    }
    public static Singleton5 getSingleton5(){
        if(singleton5 ==null){
           synchronized (Singleton5.class){
               if(singleton5 == null){
                   singleton5 = new Singleton5();
               }
           }
        }
        return singleton5;
    }
}

4.构造内部类来实现线程安全的单例模式

public class Singleton6 {
    // 内部类
     private static class  getSing{
         private final static Singleton6 singleton6 = new Singleton6(); ;
    }
    private Singleton6() {
    }
    public static  Singleton6 getSingleton6(){
         // 通过内部类获取单例对象
        // 内部类只加载一次
         return getSing.singleton6;
    }
}

5.通过枚举类来创建单例对象

public class Singleton7 {
    private Singleton7() {
    }
    enum  SingletEnum{
        INSTANCE;
        private Singleton7 instance;
        private  SingletEnum() {
            instance = new Singleton7();
        }
    }
    public  static Singleton7 getInstance(){
        return SingletEnum.INSTANCE.instance;
    }
}

以上就是关于如何创建单例模式，什么是懒汉式单例模式，什么是饿汉式单例模式，以及如何创建一个线程安全的单例模式