设计模式—单例模式

单例模式

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

目的

单例模式（Singleton）的目的是为了保证在一个进程中，某个类有且仅有一个实例。

因为这个类只有一个实例，因此，自然不能让调用方使用new Xyz()来创建实例了。所以，单例的构造方法必须是private，这样就防止了调用方自己创建实例，但是在类的内部，是可以用一个静态字段来引用唯一创建的实例的：

public class Singleton {
    // 静态字段引用唯一实例:
    private static final Singleton INSTANCE = new Singleton();

    // private构造方法保证外部无法实例化:
    private Singleton() {
    }
}

那么问题来了，外部调用方如何获得这个唯一实例？

答案是提供一个静态方法，直接返回实例：

public class Singleton {
    // 静态字段引用唯一实例:
    private static final Singleton INSTANCE = new Singleton();

    // 通过静态方法返回实例:
    public static Singleton getInstance() {
        return INSTANCE;
    }

    // private构造方法保证外部无法实例化:
    private Singleton() {
    }
}

或者直接把static变量暴露给外部：

public class Singleton {
    // 静态字段引用唯一实例:
    public static final Singleton INSTANCE = new Singleton();

    // private构造方法保证外部无法实例化:
    private Singleton() {
    }
}

5种实现方式

1. 饿汉式

利用类加载的特性：类加载的方式是按需加载，且加载一次。

就是比较“勤快”的方式，在类加载的时候，就会实例化一个对象，不管以后会不会用到，先加载再说。

// 饿汉式单例
public class Singleton {
 
    // 指向自己实例的私有静态引用，主动创建
    private static Singleton1 singleton = new Singleton();
 
    // 私有的构造方法
    private Singleton(){}
 
    // 以自己实例为返回值的静态的公有方法，静态工厂方法
    public static Singleton getSingleton(){
        return singleton;
    }
}

优点：

• 避免了线程同步问题

缺点：

• 内存资源的浪费

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

2. 懒汉式

拖延症患者，不到用到的时候就不实例化对象。

即延迟加载，只有在真正使用的时候才会实例化一个对象并交给自己的引用。

// 懒汉式单例
public class Singleton2 {
 
    // 指向自己实例的私有静态引用
    private static Singleton singleton;
 
    // 私有的构造方法
    private Singleton(){}
 
    // 以自己实例为返回值的静态的公有方法，静态工厂方法
    public static Singleton getSingleton(){
        // 被动创建，在真正需要使用时才去创建
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

优点：

• 避免了资源的浪费

缺点：

• 只能在单线程的环境下使用，多线程的环境下会出现线程同步问题。

3.双重加锁机制(双重加锁)

是线程同步安全的

public class Singleton {
    //volatile保证防止JVM指令重排，从而避免线程获得一个还没有被初始化的实例。
    private volatile static Singleton singleton;

    private Singleton() {
    }

    public Singleton getSingleton() {
        //判断是否存在对象
        if (null == singleton) {
            //不存在再加锁
            synchronized (Singleton.class) {
                if (null == singleton) {
                    singleton = new Singleton();
                }
            }
        }
        //存在直接返回
        return singleton;
    }
}

双检锁，又叫双重校验锁，综合了懒汉式和饿汉式两者的优缺点整合而成。

优点：

• 既避免了空间浪费
• 又避免了线程同步问题

4. 静态内部类

也是利用了类加载机制，但是也达到了延迟加载的目的。

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

public class Singleton {

    private Singleton() {}
	//内部类
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

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

优点: 和双重校验机制一样

• 避免了空间浪费
• 避免了线程同步问题

5. 枚举

public enum Singleton {
    INSTANCE;
    public void whateverMethod() {

    }
}

枚举的方式是比较少见的一种实现方式，但是看上面的代码实现，却更简洁清晰。并且她还自动支持序列化机制，绝对防止多次实例化。