java 多线程创建单例模式_Java设计模式（二）：单例模式的5种实现方式，以及在多线程环境下5种创建单例模式的效率...

这段时间从头温习设计模式。记载下来，以便自己复习，也分享给大家。

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种创建单例模式的效率

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();

}

}*/

选择哪种方式实现单例模式？结论：

单例对象 占用 资源 少，不需要 延迟加载：

枚举式 好于 饿汉式

单例对象 占用 资源 大，需要 延迟加载：

静态内部类式 好于 懒汉式

常用的两种方式，饿汉式和懒汉式，单例对象占用资源少时，选用饿汉式；反之，用懒汉式。

就效率来说，由于懒汉式需要同步，效率最低。

如果单例对象占用资源少，无需延迟加载，使用饿汉式或枚举式；

如果单例对象占用资源大，需要延迟加载，使用静态内部类；