java设计模式之单例模式

单例模式（Singleton Pattern）

单例模式是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

介绍

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

主要解决：一个全局使用的类频繁地创建与销毁。

何时使用：当您想控制实例数目，节省系统资源的时候。

如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

关键代码：构造函数是私有的。

创建方式

1. 饿汉式（静态常量）
2. 饿汉式 （静态代码块）
3. 懒汉式 （线程不安全）
4. 懒汉式 （线程安全，同步方法）
5. 懒汉式 （线程安全，同步代码块）
6. 双重检查
7. 静态内部类
8. 枚举

代码示例

1.饿汉式（静态常量）

步骤如下：

1. 构造器私有化（防止 new）
2. 类的内部创建对象
3. 向外暴露一个静态的公共方法。getInstance

代码如下:

public class Singlet {

    //创建对象实例
    private final static Singlet instance = new Singlet();

    //私有构造函数
    private Singlet(){
    }
    //提供一个共有的静态方法，返回实例对象
    public static Singlet getInstance(){
        return instance;
    }
}

优点：这种写法比较简单，就是再类装载的时候就完成了实例化，避免了线程同步问题。
缺点： 在类装载的时候就完成了实例化，没有达到懒加载的效果。如果从始至终没有用到这个类实例，则会造成内存的浪费。
结论： 这种单例模式可用，可能会造成内存浪费。

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

代码实例如下

public class Singlet1 {

    private static Singlet1 instance;
    private Singlet2(){}
    static{
        instance = new Singlet1();
    }
    //提供一个共有的静态方法，返回实例对象
    public static Singlet1 getInstance(){
        return instance;
    }
}

这种方式和上面的方式其实类似，只不过讲类实例化过程放在了静态代码块中，也是在类装载的时候，执行静态代码块中的代码，初始化类的实例。优缺点和上面的一样。

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

代码示例：

public class Singlet2 {

    private static Singlet2 instance;
    
    private Singlet2(){}
	//提供一个共有的静态方法，在调用该方法时才创建instance
     public static Singlet2 getInstance(){
         if (instance ==null){
             instance = new Singlet2();
         }
         return instance;
     }
}

优缺点说明：
1. 起到了懒加载的作用，但是只能在单线程下使用。
2. 如果在多线程下，一个线程进入了 if(instance ==null)判断语句，还未来的及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式。

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

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

代码实例：

public class Singlet3 {

    private Singlet3(){}

    private static Singlet3 instance;
    //加入同步处理代码，解决线程安全问题
    public static synchronized Singlet3 getInstance(){
        if (instance ==null){
            instance = new Singlet3();
        }
        return instance;
    }
}

优缺点说明：
1. 解决了线程安全问题。
2. 执行效率略低，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步，而其实这个方法只需要执行一次实例化代码就够了，其他线程想获得该类的实例，直接return就行了，方法进行同步影响效率。
结论：在实际开发中，不推荐使用这种方式

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

代码实例：

public class Singlet4 {
    private Singlet4(){}

    private static Singlet4 instance;
    //加入同步处理代码，解决线程安全问题
    public static Singlet4 getInstance(){
        if (instance ==null){
            synchronized (Singlet4.class){
                instance = new Singlet4();
            }
        }
        return instance;
    }
}

优缺点说明：
1. 这种写法，本意是相对第4种方法的改进，因为前面同步效率太低，改为同步代码块实现。
2. 但是这种同步并不能起到线程同步的作用，它跟第三种实现方式遇到的情况一样，加入一个线程进入了 if(instance ==null)判断语句块，还未来的及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。
结论: 在实际开发中，不能使用这种方式。

6.双重检查(Double-Check)

示例代码：

public class Singlet5 {

    private Singlet5(){}

    private static volatile Singlet5 instance;

    public static synchronized Singlet5 getInstance(){
        if (instance == null){
            synchronized (Singlet5.class){
                if (instance ==null){
                    instance = new Singlet5();
                }
            }
        }
        return instance;
    }
}

优缺点说明：
1. Double-Check概念是多线程开发中常使用到的，进行了两次if(instance == null)检查，这样就可以保证线程安全了。
2. 这样实例代码只执行一次。后面再次访问时，判断if(instance == null),直接返回实例化对象，也避免了反复进行方法同步。

线程安全，延迟加载，效率过高。
结论：在实际开发中，推荐使用这种写法。

7.静态内部类

代码示例：

public class Singlet6 {

    private Singlet6(){}

    private static volatile Singlet6 instance;
    //写一个静态内部类，提供一个静态属性
    private static class SingletonInstacne{
        private static final Singlet6 INSTANCE = new Singlet6();
    }

    //静态公用方法，可在直接返回
    public static synchronized Singlet6 getInstance(){
        return SingletonInstacne.INSTANCE;
    }
}

优缺点说明:
1. 这种方式采用了类加载机制来保证实例化时只有一个线程。
2. 静态内部类方式在Singlet6类被加载时并不会立即实例化，而是在需要实例化的时候，调用getInstacne方法，才会完成实例化。
3. 类的静态属性只会在第一次加载类的时候实例化，所以在这里,jvm帮助我们保证了线程的安全。在类进行初始化的时候，别的线程时无法进入的。
优点：避免了线程不安全，利用静态内部类的特点实现延迟加载，效率高。
结论： 推荐使用。

8.枚举

示例代码:

public enum Singlet7 {
    INSTANCE;
    public void Method1(){
        System.out.println("方法1");
    }

    public void Method2(){
        System.out.println("方法2");
    }
}
//调用
    public static void main(String[] args) {
        Singlet7.INSTANCE.Method1();
        Singlet7.INSTANCE.Method2();
    }

优缺点说明:
1. 这中方式是借助JDK1.5中添加枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，绝对防止多次实例化。
2. 这种方式是 Effective Java 作者 Josh Bloch 提倡的方式。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。
结论：推荐使用。

注意事项和细节说明

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