设计模式-单例模式(全)

一.单例模式的定义

就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法.

二.单例模式的八种方式

1.饿汉式(静态常量)

//饿汉式(静态常量)
public class SingletonTest1 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();           //测试
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
    }
}

class Singleton {

    private static final Singleton intance = new Singleton();            // 本类内部创建对象实例

    private Singleton() {}          // 构造器私有化
    // 3.对外提供一个公有的静态方法，返回实例对象  
    public static Singleton getInstance() {
        return intance;
    }

}

1. 构造器私有化(防止new)

2. 类的内部创建对象

3. 向外暴露一个静态的公共方法:getInstance

4. 代码实现
优点：写法简单，在类装载的时候就完成了实例化，避免了线程同步问题

缺点:在类装载的时候就完成实例化，没有达到lazy loading的效果。如果从始至终没有使用这个实例就会造成内存浪费

结论：这种单例模式可用，可能会造成内存浪费

2.饿汉式模式(静态代码块)

// 1.构造器私有化，外部不能new
    private Singleton() {

    }

    // 2.本类内部创建对象实例
    private static Singleton instance;

    static {// 在静态代码块中，创建单例对象
        instance = new Singleton();
    }

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

结论：这种单例模式可用，但是可能造成内存的浪费
3.懒汉模式(线程不安全)

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(singleton==null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时会产生多个实例，所以在多线程环境下不可使用这种方式

结论：在实际开发中，不要使用这种方式

4.懒汉式(线程安全,同步方法)

class Singleton {
    private static Singleton instance;

    private Singleton() {}

    // 提供一个静态的公有方法,当使用到该方法时，才去创建instance
    // 即懒汉模式
    //加上synchronized确保线程同步
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

解决了线程不安全的问题，但是运行效率太低了。
总结:在实际开发中，不推荐使用这种方式

5.懒汉式(线程安全,同步代码快)
6.双重检查

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.Double-Check 概念是多线程开发中常使用到的，如代码块中所示，我们进行了两次if(Singleton==null)检查，这样就可以保证线程安全了

2.这样,实例化代码只用执行一次

3.线程安全：延迟加载：效率也高

4.结论：实际开发中，推荐使用这种单例设计模式

7.静态内部类

class Singleton {
    //构造器私有化
    private Singleton() {}
    
    //写下一个静态内部类，该类中有一个静态属性Singleton
    private static class SingletonInstance{
        private static final Singleton INSTANCE = new Singleton();
    }

    // 提供一个静态的公有方法，直接返回SingletonInstance.INSTANCE
    public static  Singleton getInstance() {
      
        return SingletonInstance.INSTANCE;
    }
}

优缺点：

1.这种方式采用了类装载的机制保证了初始化实例时只有一个线程

2.静态内部类方式在Singleton类被装载时不会立即实例化，而是在需要时才实例化，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化

3.类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类初始化时，别的线程是无法进入的

4.优点：避免了线程不安全，利用了静态内部类特点实现延迟加载，效率高

8.枚举

public class SingletonTest1 {
    public static void main(String[] args) {
        Singleton instance = Singleton.INSTANCE; // 测试
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance == instance2);
    }
}

enum Singleton {
    INSTANCE;
}

优缺点：借用JDK1.5添加的枚举来实现单例模式.不仅能避免多线程同步问题，而且能防止反序列化重新创建新的对象

结论：推荐使用

单例模式注意事项和细节说明

1. 单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能
2. 当想实例化一个单例类的时候，必须记得使用相应获取对象的方法，而不是使用new
3. 使用场景：需要频繁的进行创建和销毁的对象，创建对象耗时过多或者耗费资源过多，但又经常要用到的对象，工具类对象，频繁访问数据库或者文件的对象(不如数据源，session工厂)

总结：采取一定的方法保证在整个的软件系统中，对某个类只存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)