单件模式Singleton

四种形式

1、最简单的消极型，直到调用getInstance才进行构造，但是多线程不安全。

public class SingletonHelloWorld {
    private static SingletonHelloWorld instance;

    private static int counter = 0;

    private SingletonHelloWorld() {
        counter++;
    }

    public static SingletonHelloWorld getInstance() {
        if(instance == null) {
            instance = new SingletonHelloWorld();
        }
        return instance;
    }

    public String print() {
        return "Hello World at " + counter + " time";
    }

}

2、积极型，线程安全，一开始就进行构造，但是对较大的实例来说，会浪费资源。

package com.yeweiyi.designpattern.singleton;

public class PositiveSingleton {

    private static PositiveSingleton instance = new PositiveSingleton();

    private PositiveSingleton() {}

    public static PositiveSingleton getInstance() {
        return instance;
    }

    public String print() {
        return "Hello World";
    }
}

3、利用双重锁保证线程安全的消极型，在构造前先检查instance，然后对对象加synchronize锁，再进行检查，最后调用构造器。

package com.yeweiyi.designpattern.singleton;

public class ConcurrentSafeSingleton {

    private static volatile ConcurrentSafeSingleton instance;

    private static int counter = 0;

    private ConcurrentSafeSingleton() {
        counter++;
    }

    public static ConcurrentSafeSingleton getInstance() {
        //首次检查
        if(instance == null) {
            synchronized (ConcurrentSafeSingleton.class) {
                //二次检查
                if(instance == null)
                    instance = new ConcurrentSafeSingleton();
            }
        }

        return instance;
    }
}

4、利用静态内部类实现线程安全，并因为内部类的特性，不调用不构造，来防止资源浪费。

package com.yeweiyi.designpattern.singleton;

/*
 * 使用静态内部类来完成单例的构造，且保证了线程安全
 */
public class ImprovedSingleton {

    //内部类可访问私有构造器
    private static class SingletonBuilder {
        private static ImprovedSingleton instance = new ImprovedSingleton();
    }

    private ImprovedSingleton() {}

    public ImprovedSingleton getInstance() {
        return SingletonBuilder.instance;
    }
}