SingletonExample.java
package com.cnnct.test;
import java.util.concurrent.ConcurrentHashMap;
/**
*
* @author rabbit
* @date 2013-6-20 上午18:54:57
* @email renntrabbit@foxmail.com
*
*/
public enum SingletonExample {
INSTANCE;
public static SingletonExample getInstance() {
return INSTANCE;
}
private static final ConcurrentHashMap<String, Object> MAP = new ConcurrentHashMap<String, Object>();
private Object o;
public Object getObject(Class<?> clz) throws InstantiationException, IllegalAccessException {
String key = clz.getName().toUpperCase();
o = MAP.get(key);
if (o == null) {
o = clz.newInstance();
MAP.put(key, o);
}
return o;
}
}
多线程测试
package com.cnnct.test;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
/**
*
*
* @author rabbit
* @date 2013-6-20 上午19:54:57
* @email renntrabbit@foxmail.com
*
*/
public class Test {
public static void main(String[] args) throws InstantiationException, IllegalAccessException {
Class<?>[] clz = new Class<?>[] { String.class, ConcurrentHashMap.class, Test.class };
ExecutorService executorService = Executors.newCachedThreadPool();
for (int c = 0; c < 20; c++) {
executorService.execute(new TestRun(clz));
}
executorService.shutdown();
try {
executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
} catch (Exception e) {
e.printStackTrace();
}
}
public static class TestRun implements Runnable {
private Class<?>[] clz;
public TestRun(Class<?>[] clz) {
this.clz = clz;
}
public void run() {
try {
for (Class<?> c : clz) {
Object o = SingletonExample.getInstance().getObject(c);
System.out.println(o.getClass() + "@" + o.hashCode());
}
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
}
打印结果:
class java.lang.String@0
class java.lang.String@0
class java.util.concurrent.ConcurrentHashMap@0
class java.lang.String@0
class com.cnnct.test.Test@2583282
class java.util.concurrent.ConcurrentHashMap@0
class java.lang.String@0
class java.util.concurrent.ConcurrentHashMap@0
class com.cnnct.test.Test@2583282
class java.lang.String@0
class java.util.concurrent.ConcurrentHashMap@0
class com.cnnct.test.Test@2583282
class java.lang.String@0
class java.util.concurrent.ConcurrentHashMap@0
class com.cnnct.test.Test@2583282
class java.lang.String@0
class java.util.concurrent.ConcurrentHashMap@0
class com.cnnct.test.Test@2583282
class java.lang.String@0
class java.lang.String@0
class java.lang.String@0
class java.util.concurrent.ConcurrentHashMap@0
class java.util.concurrent.ConcurrentHashMap@0
class com.cnnct.test.Test@2583282
class java.lang.String@0
class java.util.concurrent.ConcurrentHashMap@0
class com.cnnct.test.Test@2583282
class java.lang.String@0
class java.util.concurrent.ConcurrentHashMap@0
class java.lang.String@0
class java.util.concurrent.ConcurrentHashMap@0
class com.cnnct.test.Test@2583282
class java.util.concurrent.ConcurrentHashMap@0
class java.lang.String@0
class com.cnnct.test.Test@2583282
class java.util.concurrent.ConcurrentHashMap@0
class com.cnnct.test.Test@2583282
class java.util.concurrent.ConcurrentHashMap@0
class java.lang.String@0
class com.cnnct.test.Test@2583282
class com.cnnct.test.Test@2583282
class java.lang.String@0
class com.cnnct.test.Test@2583282
class java.util.concurrent.ConcurrentHashMap@0
class com.cnnct.test.Test@2583282
class java.lang.String@0
class java.util.concurrent.ConcurrentHashMap@0
class com.cnnct.test.Test@2583282
class java.lang.String@0
class java.lang.String@0
class java.lang.String@0
class java.util.concurrent.ConcurrentHashMap@0
class com.cnnct.test.Test@2583282
class com.cnnct.test.Test@2583282
class java.util.concurrent.ConcurrentHashMap@0
class com.cnnct.test.Test@2583282
class java.util.concurrent.ConcurrentHashMap@0
class com.cnnct.test.Test@2583282
class java.util.concurrent.ConcurrentHashMap@0
class com.cnnct.test.Test@2583282
分享到:
相关推荐
枚举单例模式相比其他实现方式,有以下优点: 1. 线程安全:无需额外的同步措施,JVM保证了枚举实例的唯一性。 2. 防止反射攻击:不能通过反射创建枚举类的实例,增强了单例的不可破坏性。 3. 避免序列化问题:枚举...
本文将详细讨论四种常见的单例实现方式:饿汉模式、懒汉模式、双重检查锁定(DCL)单例模式以及枚举单例。 1. **饿汉模式**: 饿汉模式是在类加载时就完成了实例化,避免了线程同步问题。这种方式简单且安全,但...
在实际应用中,还可以考虑使用枚举(Enum)方式来实现单例,它既简单又线程安全,同时避免了序列化问题。例如: ```java public enum Singleton { INSTANCE; public void studentManagement() { // 实现学生...
使用枚举是另一种线程安全且防止反射攻击的方式。 ```java public enum Singleton { INSTANCE; public void whateverMethod() {} } ``` 枚举的单例在Java中被认为是最好的实现方式,因为它不仅线程安全,...
单例设计模式案例演示 单例模式,是一种常用的软件设计模式。通过单例模式可以保证系统中,**应用该模式的这个类只有一个实例**。即一个类只有一个对象实例...枚举的定义和使用 工厂设计模式案例演示 动态代理案例演示
Java中的枚举类型是线程安全的,并且只会装载一次,设计者充分考虑到了线程安全问题,因此使用枚举实现单例模式是一种简洁而且高效的解决方案。 6. 容器式单例(Singleton Holder) 通过一个私有的静态内部类...
- 缺点:在系统启动时就占用内存,如果最终这个单例对象没有被使用,则会造成资源浪费。 2. **懒汉式(线程不安全)**:在首次使用时创建实例。 - 优点:实现了延迟加载。 - 缺点:线程不安全,多线程环境下可能...
静态内部类单例利用Java类加载机制保证了线程安全,而枚举单例则是Java中实现单例的最佳方式,因为它天然支持序列化且防止反射攻击。 在代码实现上,我们可以创建一个名为SingletonFactory的工厂类,其中包含一个...
**饿汉式**:在类加载时就完成了初始化,所以没有线程安全问题,但是不管是否使用,都会立即创建单例对象,这可能造成资源的浪费。例如: ```java class DanLi{ private static final DanLi obj = new DanLi(); ...
例如,使用枚举实现的单例模式如下: ```java public enum Singleton { INSTANCE; } ``` 枚举的单例模式简单易懂,且天然线程安全,不会受到反射和序列化攻击的影响,是推荐的单例实现方式之一。 总的来说,单例...
这个例子中,每个枚举常量都是`DayOfWeek`类型的实例,可以像普通对象一样使用。 2. 枚举方法: 枚举类默认继承了`java.lang.Enum`类,因此可以使用其内置的方法,如`name()`、`ordinal()`等。同时,我们也可以...
这种方式延迟了单例对象的初始化,直到第一次被请求时。例如,`SingleInstance1.java`可能就实现了这种方式。代码通常包含一个私有构造函数,一个私有的静态单例对象和一个公共的静态获取单例的方法。这种方法在多...
通过`SingletonFactory`,我们可以轻松地在不同的单例模式间切换,同时也可以注册自定义的单例对象。例如,如果需要自定义一个数据库连接池的单例,可以这样使用: ```java public class CustomSingleton { ...
5. **枚举单例**: 使用Java枚举实现单例,这是Effective Java作者Joshua Bloch推荐的方式,它既简单又安全,还防止了反序列化重新创建新的实例。 ```java public enum Singleton { INSTANCE; public void ...
6. 枚举型单例:JDK 1.5以后,推荐使用枚举实现单例,既简单又安全,还能防止反序列化重新创建新的实例。 ```java public enum Singleton { INSTANCE; public void whateverMethod() { //... } } ``` 7. 非...
饿汉式单例在类加载时就完成了初始化,因此线程安全,但可能会造成不必要的内存浪费,因为即使单例对象从未被使用,也会被实例化。在Java中,可以使用静态内部类的方式实现饿汉式单例,这样既能保证线程安全,又能...
此外,通过使用枚举方式实现单例,可以防止反射和序列化带来的多实例问题。 总结来说,单例模式是一种重要的设计模式,用于控制类实例的数量,以优化资源管理和提高效率。在实际开发中,我们需要根据具体需求选择...
- 与C++中的枚举不同,Java枚举默认是单例的,每个枚举值都是一个独立的对象。 3. **无缝的交互操作**: - Java枚举可以与其他语言特性无缝集成,例如,可以作为switch语句的case: ```java switch (day) { ...
《Effective Java》和《Java 与模式》等书籍推荐使用枚举实现单例,因为它们提供了一种天然的防篡改机制,保证了在任何情况下都只有一个实例。 5. **枚举的优势**: - **安全性**:枚举对象是不可变的,防止了意外...