Java设计模式-单例模式

1、概念

Java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍两种：懒汉式单例、饿汉式单例。

单例模式有以下特点：
（1）单例类只能有一个实例；
（2）单例类必须自己创建自己的唯一实例；
（3）单例类必须给所有其他对象提供这一实例；

2、代码实现

（1）懒汉式

//懒汉式单例类.在第一次调用的时候实例化自己   public class Singleton {      private Singleton() {}      private static Singleton single=null;      //静态工厂方法       public static Singleton getInstance() {           if (single == null) {                 single = new Singleton();           }            return single;      }  }  

以上懒汉式单例的实现没有考虑线程安全问题，它是线程不安全的，并发环境下很可能出现多个Singleton实例，要实现线程安全，有以下三种方式，都是对getInstance这个方法改造，保证了懒汉式单例的线程安全。

（1）在getInstance方法上加同步

public static synchronized Singleton getInstance() {      if (single == null) {            single = new Singleton();      }        return single;  }

（2）双重检查锁定

//多线程并发：原子性，可见性，有序性//一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后：//volatile让变量每次在使用的时候，都从主存中取。而不是从各个线程的“工作内存”;/**(1)保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的;(2)禁止进行指令重排序(一定程度的有序性);(3)不可保证原子性（需要synchronized，Lock等修饰）;*/private volatile static Singleton singleton;public static Singleton getInstance() {      if (singleton == null) {            synchronized (Singleton.class) {                if (singleton == null) {                    singleton = new Singleton();               }            }        }        return singleton;   } 

（3）静态内部类

public class Singleton {        //内部类不会在其外部类被加载的同时被加载    private static class LazyHolder {           private static final Singleton INSTANCE = new Singleton();        }        private Singleton (){}        public static final Singleton getInstance() {           return LazyHolder.INSTANCE;        }    } 

第三种方法较好，即实现了线程安全，又同时避免了同步带来的性能影响。

（2）饿汉式

//饿汉式单例类，在类初始化时，已经自行实例化   public class Singleton {      private Singleton() {}      private static final Singleton single = new Singleton();      //静态工厂方法       public static Singleton getInstance() {          return single;      }  }  

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。

（3）枚举类型单例模式

单例模式约束一个类只能实例化一个对象。在Java中，为了强制只实例化一个对象，最好的方法是使用一个枚举量；

• 自由序列化；
• 保证只有一个实例（即使使用反射机制也无法多次实例化一个枚举量）；
• 线程安全；

public enum AnimalHelperSingleton {      INSTANCE;      private AnimalHelperSingleton(){      }      public Animal[] buildAnimalList(){          final Animal[] animals = new Animal[10];          animals[0] = new SimpleAnimal(Animal.AnimalClass.MAMMAL,                   "Dog", true, Color.GRAY);          animals[1] = new SimpleAnimal(Animal.AnimalClass.MAMMAL,                   "Cat", true, Color.YELLOW);          animals[2] = new SimpleAnimal(Animal.AnimalClass.AMPHIBIAN,                  "Frog", true, Color.GREEN);          animals[3] = new SimpleAnimal(Animal.AnimalClass.BIRD,                  "Crow", true, Color.BLACK);          animals[4] = new SimpleAnimal(Animal.AnimalClass.BIRD,                  "Cardinal", true, Color.RED);          animals[5] = new SimpleAnimal(Animal.AnimalClass.ARTHROPOD,                  "Mantis", false, Color.GREEN);          animals[6] = new SimpleAnimal(Animal.AnimalClass.ARTHROPOD,                  "Spider", false, Color.ORANGE);          animals[7] = new SimpleAnimal(Animal.AnimalClass.MAMMAL,                   "Tiger", true, Color.ORANGE);          animals[8] = new SimpleAnimal(Animal.AnimalClass.MAMMAL,                   "Bear", true, Color.BLACK);          animals[9] = new SimpleAnimal(Animal.AnimalClass.BIRD,                   "Owl", true, Color.BLACK);          return animals;      }  }  

//调用方法Animal[] animals = AnimalHelperSingleton.INSTANCE.buildAnimalList();  

（4）懒汉式和饿汉式区别

（1）含义

懒汉式：懒汉式比较懒，只有当调用getInstance的时候，才会去初始化这个单例。

饿汉式：就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在。

（2）线程安全

懒汉式：本身是非线程安全的，可通过以上3种方法实现线程安全，这3种实现在资源加载和性能方面有些区别。

饿汉式：天生就是线程安全的，可以直接用于多线程而不会出现问题。

（3）资源加载和性能

懒汉式：会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。

饿汉式：类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成。

（4）线程安全实现方式比较

（1）在方法调用上加了同步，虽然线程安全了，但是每次都要同步，会影响性能，毕竟99%的情况下是不需要同步的。

（2）在getInstance中做了两次null检查，确保了只有第一次调用单例的时候才会做同步，这样也是线程安全的，同时避免了每次都同步的性能损耗。

（3）利用了classloader的机制来保证初始化instance时只有一个线程，所以也是线程安全的，同时没有性能损耗，推荐使用。