http://blog.csdn.net/hardwin/article/details/51480608
- package com.iter.devbox.singleton;
- /**
- * 饿汉式
- * @author Shearer
- *
- */
- public class SingletonDemo1 {
- // 类的静态成员变量只初始化一次,天然是线程安全的
- private static final SingletonDemo1 instance = new SingletonDemo1();
- private SingletonDemo1(){}
- public static SingletonDemo1 getInstance() {
- return instance;
- }
- }
- package com.iter.devbox.singleton;
- /**
- * 懒汉式
- * @author Shearer
- *
- */
- public class SingletonDemo2 {
- // 类初始化时,不初始化这个对象(延迟加载,真正用的时候再创建)
- private static SingletonDemo2 instance;
- private SingletonDemo2(){}
- // 方法同步,调用效率低
- public static synchronized SingletonDemo2 getInstance() {
- if (null == instance)
- instance = new SingletonDemo2();
- return instance;
- }
- }
- package com.iter.devbox.singleton;
- /**
- * 双重检查锁实现
- * 将同步放到if内部,提高了执行的效率。
- * 不必每次获取对象时都进行同步,只有第一次才同步。
- * 创建了以后就没有必要了。
- * 问题:
- * 由于编译器优化原因和JVM底层内部模型原因,偶尔会出问题,不建议使用。
- * @author Shearer
- *
- */
- public class SingletonDemo3 {
- private static SingletonDemo3 instance = null;
- private SingletonDemo3(){}
- public static SingletonDemo3 getInstance() {
- if (null == instance) {
- SingletonDemo3 sc;
- synchronized (SingletonDemo3.class) {
- sc = instance;
- if (null == sc) {
- synchronized (SingletonDemo3.class) {
- if (null == sc) {
- sc = new SingletonDemo3();
- }
- }
- instance = sc;
- }
- }
- }
- return instance;
- }
- }
- package com.iter.devbox.singleton;
- /**
- * 静态内部类实现方式(也是一种懒加载方式)
- * 这种方式:线程安全,调用效率高,并且实现了延迟加载
- * @author Shearer
- *
- */
- public class SingletonDemo4 {
- private static class SingletonClassInstance {
- private static final SingletonDemo4 instance = new SingletonDemo4();
- }
- // 方法没有同步,调用效率高
- public static SingletonDemo4 getInstance() {
- return SingletonClassInstance.instance;
- }
- private SingletonDemo4(){}
- }
- package com.iter.devbox.singleton;
- /**
- * 通过枚举实现单例模式(没有延迟加载)
- * 线程安全,调用效率高,不能延迟加载。
- * 并且可以天然的防止反射和反序列化漏洞
- * @author Shearer
- *
- */
- public enum SingletonDemo5 {
- // 枚举元素,本身就是单例对象
- INSTANCE;
- // 可以添加自己需要的操作
- public void singletonOperation() {
- System.out.println("枚举类里面的方法调用");
- }
- }
测试多线程环境下5种创建单例模式的效率
[java] view plain copy
- package com.iter.devbox.singleton;
- import java.util.concurrent.CountDownLatch;
- /**
- * 测试多线程环境下5种创建单例模式的效率
- *
- * @author Shearer
- *
- */
- public class Client4 {
- public static void main(String[] args) throws Exception {
- long begin = System.currentTimeMillis();
- int threadNum = 100; // 100个线程(10个线程的情况下,运行多次有时候耗时为0!所以让线程多一点!)
- final CountDownLatch countDownLatch = new CountDownLatch(threadNum);
- for (int i = 0; i < threadNum; i++) {
- new Thread(new Runnable() {
- @Override
- public void run() {
- for (int i = 0; i < 100000; i++) {
- Object obj1 = SingletonDemo1.getInstance(); // 15.饿汉式
- // Object obj2 = SingletonDemo2.getInstance(); // 156.懒汉式
- // Object obj3 = SingletonDemo3.getInstance(); // 16.双重检查锁,不要使用!
- // Object obj4 = SingletonDemo4.getInstance(); // 15.静态内部类
- // Object obj5 = SingletonDemo5.INSTANCE; // 16.枚举实现
- }
- countDownLatch.countDown();
- }
- }).start();
- }
- /* for (int i = 0; i < threadNum; i++) {
- new Thread(new MyRunnable(countDownLatch)).start();
- }*/
- countDownLatch.await(); // main线程阻塞,直到计数器变为0,才会继续往下执行
- long end = System.currentTimeMillis();
- System.out.println("总耗时:" + (end - begin));
- }
- }
- /*class MyRunnable implements Runnable {
- private CountDownLatch countDownLatch;
- public MyRunnable(CountDownLatch countDownLatch) {
- this.countDownLatch = countDownLatch;
- }
- @Override
- public void run() {
- for (int i = 0; i < 100000; i++) {
- // Object obj1 = SingletonDemo1.getInstance(); // 15.饿汉式
- // Object obj2 = SingletonDemo2.getInstance(); // 156.懒汉式
- // Object obj3 = SingletonDemo3.getInstance(); // 16.双重检查锁,不要使用!
- // Object obj4 = SingletonDemo4.getInstance(); // 31.静态内部类
- Object obj5 = SingletonDemo5.INSTANCE; // 16.枚举实现
- }
- countDownLatch.countDown();
- }
- }*/
选择哪种方式实现单例模式?结论:
单例对象 占用 资源 少,不需要 延迟加载:
枚举式 好于 饿汉式
单例对象 占用 资源 大,需要 延迟加载:
静态内部类式 好于 懒汉式
常用的两种方式,饿汉式和懒汉式,单例对象占用资源少时,选用饿汉式;反之,用懒汉式。
就效率来说,由于懒汉式需要同步,效率最低。
如果单例对象占用资源少,无需延迟加载,使用饿汉式或枚举式;
如果单例对象占用资源大,需要延迟加载,使用静态内部类;