java设计模式之单例模式
单例模式（Singleton Pattern）
单例模式是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
介绍
意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
主要解决：一个全局使用的类频繁地创建与销毁。
何时使用：当您想控制实例数目，节省系统资源的时候。
如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。
关键代码：构造函数是私有的。
创建方式
- 饿汉式（静态常量）
- 饿汉式 （静态代码块）
- 懒汉式 （线程不安全）
- 懒汉式 （线程安全，同步方法）
- 懒汉式 （线程安全，同步代码块）
- 双重检查
- 静态内部类
- 枚举
代码示例
1.饿汉式（静态常量）
步骤如下：
- 构造器私有化（防止 new）
- 类的内部创建对象
- 向外暴露一个静态的公共方法。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 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。
结论：推荐使用。
注意事项和细节说明
- 单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。
- 当想实例化一个单例类的时候，必须要记住使用相应的获取对象方法，而不是new。
- 使用场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或者耗费资源过多（重量级对象），但又不经常使用到的对象、工具类对象，频繁访问数据库文件的对象（比如数据源、session工厂）。