设计模式 - 单例模式

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

单例模式共有8种方式：

• 饿汉式（静态常量），可以使用
• 饿汉式（静态代码块），可以使用
• 懒汉式（线程不安全），不推荐使用
• 懒汉式（同步方法），线程安全，可以使用，但是不推荐
• 懒汉时（同步代码块），想解决线程安全问题，但是这是一种错误的方法，没有解决线程安全问题。不能使用
• 双重检查，推荐使用
• 静态内部类，推荐使用
• 枚举，推荐使用

1 饿汉式

饿汉式，类很饿，饥不择食，一上来就会创建对象实例。饿汉式不存在线程安全问题。

1.1 静态常量

步骤：

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

代码实现：

public class User {
		// 静态常量
    private static final User user = new User();
    // 私有化构造器，方式外部通过new来创建对象
    private User(){
    }
		// 对外暴露的方法
    public static User getInstance() {
        return user;
    }
}

优点：

• 写法简单，在类装载的时候就完成了实例化，避免了线程同步问题。

缺点：

• 在类装载时就完成类实例化，没有达到懒加载（Lazy Loading）的效果。如果从未使用过这个实例，则会造成内存的浪费。

总结：这种单例模式可用，但是可能造成内存浪费。

1.2 静态代码块

public class Book {
    private static Book book;
    // 静态代码块
    static {
        book = new Book();
    }
    // 私有化构造方法，防止外部通过new的方式创建对象
    private Book() {}
    // 对外暴露获取实例的方法
    public static Book getInstance() {
        return book;
    }
}

该方法和静态常量方法类似。优点缺点与静态常量方法相同。

2 懒汉时

2.1 线程不安全

public class Dog {
    private static Dog dog;
    // 私有化构造方法，防止外部通过new的方式创建对象
    private Dog() {}
    // 对外暴露获取实例的方法，当调用该方式时，才会创建实例对象
    public static Dog getInstance() {
        if (dog==null){
            dog = new Dog();
        }
        return dog;
    }
}

优点：

• 起到了懒加载的效果，但是只能在单线程下使用。

缺点：

• 如果在多线程下，一个线程进行了if(dog==null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例，所以在多线程环境下不可使用这种方式。

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

2.2 同步方法-线程安全

public class Cat {
    private static Cat cat;
		// 私有化构造方法，防止外部通过new的方式创建对象
    private Cat() {}
		// 对外暴露获取实例的方法，当调用该方式时，才会创建实例对象。使用synchronized关键字保障线程安全
    public static synchronized Cat getInstance(){
        if(cat == null){
            cat = new Cat();
        }
        return cat;
    }
}

优点：

• 解决了线程不安全问题。

缺点：

• 效率太低了，每个线程在想获得类的实例的时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面想获得该类实例，直接return就行了。方法进行同步效率太低。

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

2.3 同步代码块-不能解决线程安全

在实际开发中，有人尝试解决线程安全问题，但是又想解决同步方法带来的效率低的问题，所以使用了下面的方法。将cat = new Cat()创建新实例的代码放入了一个同步代码块中。

但是这种方法其实并没有解决线程安全问题。因为可能会多个线程通过if(cat == null)判断，也会造成多次创建实例的情况。

public class Cat {
    private static Cat cat;
		// 私有化构造方法，防止外部通过new的方式创建对象
    private Cat() {}
		// 对外暴露获取实例的方法，当调用该方式时，才会创建实例对象。
    public static Cat getInstance(){
        if(cat == null){
          	// 同步代码块
            synchronized (Cat.class){
                cat = new Cat();
            }
        }
        return cat;
    }
}

这是一种错误写法！！

2.4 双重检查

volatile关键字可以让修改值立即更新到主存。在对象的构造过程中，volatile 可以确保在对象引用被赋值给其他线程之前，对象的构造过程已经完成。

如果不加volatile关键字，一个线程修改了 pig 的值，其他线程可能看不到这个修改，导致可能创建多个实例。

public class Pig {
    private static volatile Pig pig;
    // 私有化构造方法，防止外部通过new的方式创建对象
    private Pig() {}
    // 对外暴露获取实例的方法，当调用该方式时，才会创建实例对象。
    public static Pig getInstance() {
        if (pig == null) {
            synchronized (Pig.class) {
              	// 再次检查 
                if (pig == null) {
                    pig = new Pig();
                }
            }
        }
        return pig;
    }
}

双重检查这种方式，在保证线程安全的同时，也具有较高的效率。在实际开发中，推荐使用这种方法。

2.5 静态内部类

当Tigger类进行装载时，TiggerInstance静态内部类是不会被装载的。

当我们调用getInstance方法时，会装载TiggerInstance内部类，同时静态内部类的静态常量INSTANCE对象会被创建。

public class Tigger {
  	// 私有化构造方法，防止外部通过new的方式创建对象
    private Tigger(){}
		// 静态内部类
    private static class TiggerInstance {
        private static final Tigger INSTANCE = new Tigger();
    }
		// 对外暴露获取实例的方法，当调用该方式时，才会创建实例对象。
    private static Tigger getInstance(){
        return TiggerInstance.INSTANCE;
    }
}

这种方式采用类加载的机制来保证初始化实例时只有一个线程。

这种方法保证了线程安全，效率高。推荐使用！

2.6 枚举

public enum Fish {
    INSTANCE;
    public void sayOK(){
        System.out.println("ok");
    }
}

借助枚举实现单利模式，可以避免多线程同步问题，而且还能防止反序列化重新创建新的对象。推荐使用。

3 单例模式注意事项

单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。

当想实例化一个单例类的时候，必须要使用相应的获取对象的方法，而不是直接用new。

单例模式使用的场景：

• 需要频繁的进行创建和销毁的对象
• 创建对象时耗时过多或耗费资源过多（即重量级对象），但又经常用到的对象
• 工具类对象
• 频繁访问数据库或文件的对象，比如数据源、session工厂等