单例模式

定义：采用一定的方法保证在整个的软件系统中，<mark>对某个类只能存在一个对象实例</mark>，并且该类只能提供一个取得其对象实例的方法()。

单例模式的八种方式

饿汉式（静态常量）

步骤：

• 构造器私有化
• 类的内部对象创建
• 向外暴露一个静态的公共方法
• 代码实现

代码实现

//饿汉式实现(静态遍历)
class Singleton{
    //1.构造器私有化，外部不能new
    private Singleton(){}

    //奔雷内部创建对象实例
    private final static Singleton instance = new Singleton();

    //提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance(){
        return instance;
    }
}

验证测试

public class SingletonTest01 {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
       System.out.println(instance1==instance2);
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}

控制台输出结果

优缺点说明

1. 写法简单，在类装载的时候完成了实例化，避免了线程同步问题
2. 在类加载的时候完成实例化，没有达到lazy Loading的效果，如果从始至终未使用该实例，则会造成内存的浪费。
3. 这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，在单例模式中大多数都是调用getIstance()方法，但是导致类转载的原因有许多，不能确定有其他方式（或其他静态方法）导致类装载，这时候初始化instance就没有达到lazy loading的效果
4. <mark>所以，该单例模式可用，但是可能造成内存浪费</mark>

饿汉式（静态代码块）

代码实现

//饿汉式实现(静态代码块)
class Singleton{
   //1.构造器私有化，外部不能new
   private Singleton(){}

   //奔雷内部创建对象实例
   private static Singleton instance;

   //在静态代码块中创建单例对象
   static {
       instance = new Singleton();
   }
   //提供一个公有的静态方法，返回实例对象
   public static Singleton getInstance(){
       return instance;
   }
}

优缺点说明

1. 这种方式和上一种类似，只是将实例化的过程放在了静态代码块中，也是在类加载的时候，就执行了静态代码块中的代码，初始化类的实例，优缺点和上面相同
2. <mark>该单例模式可用，但是可能造成内存浪费</mark>

懒汉式(线程不安全)

代码实现

class Singleton{
    private static Singleton instance;

    private Singleton(){};

    //提供一个静态的额公有方法，当使用到该方法时，才去创建instance
    //懒汉式
    public static Singleton getInstance(){
        if(instance==null){
            instance = new Singleton();
        }
        return instance;
    }
}

测试结果

优缺点说明

1. 起到了Lazy Loading的效果，但只能在单线程下使用
2. 如果在多线程下，一个线程进入 if判断语句块，还没来得及执行，另一个线程也通过该判断语句，就会产生多个实例，所以，在多线程环境下不可使用这种方式
3. <mark>在实际开发中，不要使用该方式</mark>

懒汉式(线程安全，同步代码)

代码实现

//懒汉式(线程安全，同步代码)
class Singleton{
    private static Singleton instance;

    private Singleton(){};

    //提供一个静态的额公有方法，加入同步处理代码 synchronized
    //懒汉式
    public static synchronized Singleton getInstance(){
        if(instance==null){
            instance = new Singleton();
        }
        return instance;
    }
}

优缺点说明

1. 解决了线程不安全的问题
2. 效率太低了，每个线程在获取类的实例时，都要执行getInstance()方法来进行线程同步。
3. <mark>在实际开发中，不推荐使用这种方式</mark>

懒汉式(线程安全，同步代码块)

代码实现

//懒汉式(线程安全，同步代码块)
class Singleton{
    private static Singleton instance;

    private Singleton(){};

    //提供一个静态的额公有方法，加入同步处理代码 synchronized
    //懒汉式
    public static Singleton getInstance(){
        if(instance==null){
            synchronized(Singleton.class) {
                instance = new Singleton();
            }
        }
        return instance;
    }
}

优缺点说明

1. 此处无法实现代码同步，原因同懒汉式（线程不安全的方式），如果多个线程同时进入到if判断语句，就会产生多个实例
2. <mark>实际开发中不能使用</mark>

双重检查

代码实现

//双重检查
class Singleton{
    private static volatile Singleton instance;

    private Singleton(){};

    //提供一个静态的额公有方法，加入双重检查代码
    //懒汉式
   public static synchronized Singleton getInstance(){
        if(instance==null){
            synchronized(Singleton.class) {
                if(instance==null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

优缺点说明

1. 双检查概念是多线程开发中常使用的，入代码中所示，进行两次if(instance==null)的检查，保证线程安全
2. 实例化代码只执行一次，第二次访问会判断不为空，避免了反复的方法同步
3. <mark>在实际开发中，推荐使用这种单例模式</mark>

静态内部类

特点

1. 当Singleton进行类装载时，静态内部类不会被装载
2. 当调用getInstance方法调用静态内部类的INSTANCE的时候，静态内部类被装载，且只装载一次
   代码实现

//静态内部类
class Singleton{
    private static volatile Singleton instance;
    //构造器私有化
    private Singleton(){};
    //静态内部类
    private static class SingletonInstance{
        private static final Singleton INSTANCE = new Singleton();
    }

    public static synchronized Singleton getInstance(){
        return SingletonInstance.INSTANCE;
    }
}

优缺点说明

1. 这种采用了类装载的机制了来保证初始化实例时只有一个线程
2. 静态内部类装载在Singleton类被装载时不会立即实例化，在调用getInstance方法时才会完成实例化
3. 类的静态属性只会在第一次加载类时初始化，所以，JVM保证 了线程的安全性，类进行初始化时，其他线程无法进入
4. 避免了线程不安全，利用静态内部类实现延迟加载，效率高
5. <mark>推荐使用</mark>

枚举

代码实现

enum Singleton{
    INSTANCE;
    public void sayOk(){
        System.out.println("ok");
    }
}

测试结果

优缺点说明

1. 借助枚举来实现单例模式，不仅避免多线程问题，而且还能放置反序列化重新创建的对象
2. <mark>推荐使用</mark>

单例模式在JDK中的使用

饿汉式，静态常量

单例模式的注意事项

1. 为了保证系统中只存在一个对象时，使用单例模式提高系统性能
2. 当实例化一个单例类时，务必记住使用相应的获取对象的方法，不用new

使用场景

需要频繁的进行创建和销毁的对象，创建对象时，耗时或耗用资源过多，但又经常使用的对象、工具类对象、频繁访问的数据库或文件对象（比如数据源、sessionFactory等）

单例模式源码（可以下载下来学习）

单例模式源码

相关推荐
设计模式目录