Singleton Pattern单例模式
单例模式是一种对象创建模式，它用于产生一个对象的具体实例，它可以确保系统中一个类只产生一个实例。Java里面实现的单例是一个虚拟机的范围，因为装载类的功能是虚拟机的，所以一个虚拟机在通过自己的 ClassLoad 装载实现单例类的时候就会创建一个类的实例。在 Java语言中，这样的行为能带来两大好处：
-
对于频繁使用的对象，可以省略创建对象所花费的时间，这对于那些重量级对象而言，是非常可观的一笔系统开销；
-
由于 new 操作的次数减少，因而对系统内存的使用频率也会降低，这将减轻 GC 压力，缩短 GC 停顿时间。
因此对于系统的关键组件和被频繁使用的对象，使用单例模式可以有效地改善系统的性能。单例模式的核心在于通过一个接口返回唯一的对象实例。首要的问题就是要把创建实例的权限收回来，让类自身来负责自己类的实例的创建工作，然后由这个类来提供外部可以访问这个类实例的方法
单例模式基本实现
/** * 单例模式基本实现 */ public class Singleton { // 首先单例模式必须要有一个private访问级别的构造函数，才能确保单例不会在系统中其他代码内被实例化，其次，instance 成员变量和 // getInstance 方法必须是 static 的。 private static Singleton instance = new Singleton(); private Singleton() { } public static Singleton getInstance() { return instance; } }
上述代码唯一的不足是无法对 instance 实例做延时加载，例如单例的创建过程很慢，而由于 instance 成员变量是 static 定义的，因此在 JVM加载单例类时，单例对象就会被建立，如果此时这个单例类在系统中还扮演其他角色，那么在任何使用这个单例类的地方都会初始化这个单例变量，而不管是否会被用到。
单例模式实验
public class Singleton { private Singleton() { System.out.println("Singleton is create"); } private static Singleton instance = new Singleton(); public static Singleton getInsatnce() { return instance; } public static void createString() { System.out.println("createString in Singleton"); } public static void main(String[] args) { Singleton.createString(); } }
上述代码运行后的输出如
Singleton is create
createString in Singleton
可以看到，虽然此时并没有使用单例类，但它还是被创建出来，为了解决这类问题，需要引入延迟加载机制。
//延迟加载的单例模式 public class LazySingleton { private LazySingleton() { System.out.println("LazySingleton is create"); } private static LazySingleton instance = null; public static synchronized LazySingleton getInstance() { if (instance == null) { instance = new LazySingleton(); } return instance; } public static void createString() { System.out.println("create String"); } public static void main(String[] args) { LazySingleton.createString(); } }
上述代码运行后的输出如
create String
上述代码首先对于静态成员变量 instance 初始化赋值 null，确保系统启动时没有额外的负载；其次，在 getInstance()工厂方法中，判断当前单例是否已经存在，若存在则返回，不存在则再建立单例。这里尤其要注意的是，getInstance() 方法必须是同步的，否则在多线程环境下，当线程1正新建单例时，完成赋值操作前，线程2可能判断instance为null，故线程2也将启动新建单例的程序，而导致多个实例被创建，故同步关键字是必须的。由于引入了同步关键字，导致多线程环境下耗时明显增加,两者测试代码如下
非同步的单例模式代码
public class Singleton implements Runnable{ private Singleton() { System.out.println("Singleton is create"); } private static Singleton instance = new Singleton(); public static Singleton getInsatnce() { return instance; } public static void createString() { System.out.println("createString in Singleton"); } public static void main(String[] args) { //Singleton.createString(); for (int i = 0; i < 5; i++) { new Thread(new Singleton()).start(); } } @Override public void run() { long beginTime=System.currentTimeMillis(); for (int i = 0; i < 100000000; i++) { Singleton.getInsatnce(); } System.out.println(System.currentTimeMillis()-beginTime); } }
代码运行后输出
Singleton is create
Singleton is create
Singleton is create
Singleton is create
Singleton is create
Singleton is create
1
0
1
2
0
完整的延迟加载方式代码
public class LazySingleton implements Runnable{ private LazySingleton() { System.out.println("LazySingleton is create"); } private static LazySingleton instance = null; public static synchronized LazySingleton getInstance() { if (instance == null) { instance = new LazySingleton(); } return instance; } public static void createString() { System.out.println("create String"); } public static void main(String[] args) { //LazySingleton.createString(); for (int i = 0; i < 5; i++) { new Thread(new LazySingleton()).start(); } } @Override public void run() { long beginTime=System.currentTimeMillis(); for (int i = 0; i < 100000000; i++) { LazySingleton.getInstance(); } System.out.println(System.currentTimeMillis()-beginTime); } }
代码运行后输出
LazySingleton is create
LazySingleton is create
LazySingleton is create
LazySingleton is create
LazySingleton is create
LazySingleton is create
5125
5261
5270
5440
5454
为了解决同步关键字降低系统性能的缺陷，做了一定改进
//延迟加载的单例模式 public class LazySingleton implements Runnable{ private LazySingleton() { System.out.println("LazySingleton is create"); } private static LazySingleton instance = null; public static LazySingleton getInstance() { if (instance == null) { synchronized (LazySingleton.class) { if (instance == null) { instance = new LazySingleton(); } } } return instance; } public static void createString() { System.out.println("create String"); } public static void main(String[] args) { for (int i = 0; i < 5; i++) { new Thread(new LazySingleton()).start(); } } @Override public void run() { long beginTime=System.currentTimeMillis(); for (int i = 0; i < 100000000; i++) { LazySingleton.getInstance(); } System.out.println(System.currentTimeMillis()-beginTime); } }
首先判断instance是不是为null，如果为null，加锁初始化；如果不为null，直接返回instance。
/** * 解决同步关键字低效率 * */ public class StaticSingleton { private StaticSingleton() { System.out.println("StaticSingleton is create"); } private static class SingletonHolder { private static StaticSingleton instance = new StaticSingleton(); } public static StaticSingleton getInstance() { return SingletonHolder.instance; } }
单例模式使用内部类来维护单例的实例，当 StaticSingleton 被加载时，其内部类并不会被初始化，故可以确保当 StaticSingleton 类被载入 JVM 时，不会初始化单例类，而当 getInstance() 方法调用时，才会加载 SingletonHolder，从而初始化instance。同时，由于实例的建立是时在类加载时完成，故天生对多线程友好，getInstance() 方法也无需使用同步关键字。
登记式单例
- //类似Spring里面的方法，将类名注册，下次从里面直接获取。
public class Singleton3 { private static Map<String, Object> map = new HashMap<String, Object>(); static { /*Singleton3 single = new Singleton3(); map.put(single.getClass().getName(), single);*/ } // 保护的默认构造子 protected Singleton3() { } // 静态工厂方法,返还此类惟一的实例 public static Object getInstance(String name) { if (name == null) { name = Singleton3.class.getName(); System.out.println("name == null" + "--->name=" + name); } if (map.get(name) == null) { try { map.put(name, Class.forName(name).newInstance()); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } } return map.get(name); } public static void main(String[] args) { Singleton3 single3 =(Singleton3) Singleton3.getInstance("demo.pattern.singleton.Singleton3"); Singleton3 single2 =(Singleton3) Singleton3.getInstance("demo.pattern.singleton.Singleton3"); System.out.println(single2); System.out.println(single3); } }
登记式单例实际上维护了一组单例类的实例，将这些实例存放在一个Map（登记薄）中，对于已经登记过的实例，则从Map直接返回，对于没有登记的，则先登记，然后返回。