Java单例模式的实现方法

1. 阐述单例模式
单例模式是一种设计模式，就是说单例对象的类只可以有一个实例对象存在。由自己来创建自己的对象，同时确保只可以有一个对象，而且当你访问的时候只可以直接访问，不需要实例化这个对象。
它实现方式主要是有懒汉式和饿汉式两种
2. 饿汉式实现
直接创建实例化对象，不管你是否需要这个对象
饿汉式没是线程安全的
饿汉式最简单的实现方法是枚举类
1). 第一种实现规则
构造器私有化
自行创建，并且使用静态变量保存
向外提供这个实例
强调这是一个单例，用final修饰

public class Singleton1 {

    public static final Singleton1 INSTANCE = new Singleton1();

    private Singleton1(){

    }

}

Singleton1 s = Singleton1.INSTANCE;

2).枚举实现规则
枚举类型：表示该类型的对象是有限的几个
我们可以限定为一个，就成了单例

public enum SingleTon2 {
    INSTANCE
}

实现

//枚举类型
      SingleTon2 s2 = SingleTon2.INSTANCE;

3).使用静态代码块实现
当有变量需要实例化的时候可以使用这个方法

public class Singleton3 {

    public static final Singleton3  INSTANCE  ;

      static {
          INSTANCE = new Singleton3();
      }
    private Singleton3(){

    }
}

3. 懒汉式实现
延迟加载创建这个对象
懒汉式最简单的实现方法是静态内部类实现方法

1).第一种实现规则（适用于单线程）
构造方法私有化
用一个静态变量保存唯一实例
提供一个静态方法得到实例

public class SingleTon4 {
    private static SingleTon4 instance;
    private SingleTon4(){

    }

    public static SingleTon4 getSingleTon4(){
        if (instance == null){
            instance = new SingleTon4();
        }
        return instance;
    }
}

这种方法只适用于单线程，有线程安全问题，因为当一个线程进来时候，它先判断instance是否为空，这时它没有实例化，确实为空，但是如果在实例化的过程中这个线程遇到休眠，然后还没有来得及创建，这时有另一个线程进来了，然后它再判断instance是否为空的时候，instance还是为空，然后如果这个线程也遇到休眠，然后第一个进来的线程再次运行时会示例化instance，但是这时第二个线程也会实例化instance，所以得到的不是同一个对象，这两个对象的地址也会不相同，所以说这种方式存在线程安全问题

这个时候是用线程安全问题的

 Callable<SingleTon4> callable = new Callable<SingleTon4>() {
           @Override
           public SingleTon4 call() throws Exception {
               return SingleTon4.getSingleTon4();
           }
       };
       ExecutorService ex = Executors.newFixedThreadPool(2);
       Future<SingleTon4> f1 = ex.submit(callable);
       Future<SingleTon4> f2 = ex.submit(callable);

      SingleTon4 s1 = f1.get();
      SingleTon4 s2 = f2.get();
       System.out.println(s1 == s2);
       System.out.println(s1);
       System.out.println(s2);

2).解决线程安全实现方法（适用于多线程）

public class Singleton5 {//这种方式来解决线程安全问题，可以实现多线程

    private static Singleton5 instance;
    private Singleton5(){

    }

    public static Singleton5 getSingleTon5(){
        synchronized (Singleton5.class){
            if (instance == null){
                instance = new Singleton5();
            }
        }
        return instance;
    }
}

这里加了synchronized关键字，然后用来解决线程安全

   Callable<Singleton5> callable = new Callable<Singleton5>() {
           @Override
           public Singleton5 call() throws Exception {
               return Singleton5.getSingleTon5();
           }
       };
       ExecutorService ex = Executors.newFixedThreadPool(2);
       Future<Singleton5> f1 = ex.submit(callable);
       Future<Singleton5> f2 = ex.submit(callable);

       Singleton5 s1 = f1.get();
       Singleton5 s2 = f2.get();
       System.out.println(s1 == s2);
       System.out.println(s1);
       System.out.println(s2);

3).内部类实现（适用于多线程）
在内部类被初始化和赋值时才会创建实例化对象
静态内部类不会随着外部类的加载和初始化而初始化的，它是独立去加载的
因为是在内部类加载和初始化时创建的，因此时线程安全的

public class Singleton6 {//适用于多线程
    private Singleton6(){

    }

    private static class Inner{
        private static final Singleton6 INSTANCE = new Singleton6();
    }

    public static Singleton6 getInstance(){
        return Inner.INSTANCE;
    }

}