判断是否存在

/**
 * 懒汉式
 */
public class LazySingleInstance {

    // 私有构造方法
    private LazySingleInstance(){};

    // 私有的类对象
    private static LazySingleInstance instance = null;

    // 缺点：
    // 1 每次都需要去判断instance 是否为空
    // 2 调用时才去new对象，响应比较慢
    // 3 多线程时，线程不安全，多线程同时获取该对象，线程不安全，可能会产生多个对象出来
    public static LazySingleInstance getInstance() throws InterruptedException {
        // 每次都需要判断instance是否为空，浪费资源
        if (null == instance) {
            Thread.sleep(1000);
            instance = new LazySingleInstance();
        }

        return instance;
    }
}

考虑线程

/**
 * 懒汉式线程安全方法一
 */

public class ThreadSafeSingleInstance {

    // 私有的静态实例
    private static ThreadSafeSingleInstance instance;

    // 私有的构造方法
    private ThreadSafeSingleInstance(){};

    /**
     * 懒汉式线程安全方法
     * 同步锁保护
     * 缺点：
     * 性能低下，且同时每次均需检查实例是否存在
     * @return
     * @throws InterruptedException
     */
    public synchronized static ThreadSafeSingleInstance getInstance() throws InterruptedException {
        if (instance == null) {
            Thread.sleep(1000);
            instance = new ThreadSafeSingleInstance();
        }

        return instance;
    }

}

/**
 * 懒汉式线程安全方法二
 */
public class ThreadSafeSingleInstance {

    // 私有的静态实例
    private static ThreadSafeSingleInstance instance;

    // 私有的构造方法
    private ThreadSafeSingleInstance(){};

    /**
     * 同步块保护加二次判断
     * 解决问题
     */
    public static ThreadSafeSingleInstance getInstance() throws InterruptedException {
        if (instance == null) {
            // 进方法后进行实例判断，若实例为空，进入同步块
            // 多线程时，多个线程会同时进入到同步块外面等待
            // 此时，一个线程拿到ThreadSafeSingleInstance.class 后，其他线程在synchronized块外面等待
            // 待锁释放时，一个等待的线程拿到锁，同时再次检查实例是否为空
            // 并决定是否要创建实例
            synchronized (String.class) {//ThreadSafeSingleInstance.class) {
                Thread.sleep(1000);
                if (instance == null) {
                    instance = new ThreadSafeSingleInstance();
                }
            }
        }

        return instance;
    }

}

每次都去new

/**
 * 饿汉式
 */
public class HungrySingleInstance {

    // 私有的构造方法
    private HungrySingleInstance(){};

    // 静态类变量,初始化类时变创建对象
    private static HungrySingleInstance instance = new HungrySingleInstance();

    // 或采用静态块形式初始化instance
    static {
        instance = new HungrySingleInstance();
    }

    /**
     * 获取实例方法
     * 优点：
     * 线程安全，且不存在懒汉式的二次判断问题
     * 缺点：
     * 初始化即new 实例对象出来，违背资源利用习惯（即不管用不用都初始化实例出来）
     * @return
     */
    public static HungrySingleInstance getInstance() {
        return instance;
    }
}

测试类

public class SingleInstanceTest implements Runnable{

    HungrySingleInstance hungrySingleInstance = null;

    LazySingleInstance lazySingleInstance = null;

    ThreadSafeSingleInstance threadSafeSingleInstance = null;

//  @Override
//  public void run() {
//      hungrySingleInstance = HungrySingleInstance.getInstance();
//      System.out.println("hungrySingleInstance.hashCode() " + hungrySingleInstance.hashCode());
//
//  }

//  @Override
//  public void run() {
//      try {
//          lazySingleInstance = LazySingleInstance.getInstance();
//      } catch (InterruptedException e) {
//          e.printStackTrace();
//      }
//      System.out.println("lazySingleInstance.hashCode() " + lazySingleInstance.hashCode());
//  }

    @Override
    public void run() {
        try {
            threadSafeSingleInstance = ThreadSafeSingleInstance.getInstance();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("threadSafeSingleInstance() " + threadSafeSingleInstance.hashCode());
    }

    public static void main(String args[]) throws InterruptedException{
        SingleInstanceTest singleInstanceTest = new SingleInstanceTest();

        for (int i=0; i< 100; i++) {
            Thread t = new Thread(singleInstanceTest, String.valueOf(i));
            t.start();
        }
    }
}