1. 1. 双重检查加锁机制，指的是：并不是每次进入getInstance()都需要同步，而是先不同步，进入方法过后，先检查实例是否存在，如果不存在才进入同步块，这是第一重检查。进入同步块后，再次检查实例是否存在，如不不存在，就在同步的情况下创建一个实例，这是第二重检查。  这样以来，只需用同步一次了（指检查阶段），从而减少了多次在同步情况下进行判断所浪费的时间
   
2. 双重检查加锁机制的实现会使用一个关键字volatile,它的意思是：被volatile修饰的变量的值，将不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存，从而确保多个线程能够正确处理变量。
   
3. public class Singleton {
   
4. private volatile static Singleton instance = null;//被volatile修饰的变量
   
5. private Singleton() {}//私有构造方法
   
6. public static Singleton getInstance() {
   
7. if (instance == null) {
   
8. //同步块，线程安全的创建实例
   
9. synchronized(Singleton.class){
   
10. if(instance == null){
    
11. instance = new Singleton();
    
12. }
    
13. }
    
14. }
    
15. return instance;
    
16. }
    
17. 2. 类级内部类相当于其外部类的static成分，它的对象与外部类对象间不存在依赖关系，因此可以直接创建。而对象级内部类的实例，是绑定在外部对象实例中的，属聚合关系。  类级内部类中，可以定义静态的方法，在静态方法中只能够引用外部类中的静态成员方法或者成员变量（因为是static的类，需要引用外部类标为static的成员变量或方法 ）。 类级内部类相当于其外部类的成员（这个很容易理解，依附于谁，就是谁的一部分），只有在第一次使用的时候才会被装载（相当于静态可共享的成员变量）。
    
18. 类级内部类与线程同步锁的关系：在Java中，解决线程并发问题主要通过使用synchronized来加互斥锁进行同步控制。但是在某些情况下，jvm已经隐含的为你执行了同步
    
19. public class Singleton {
    
20. /*类级内部类的实例与外部类的实例没有绑定关系，而且只有在被调用的时候才会装载，从而实现了延迟加载*/
    
21. private static class SingletonHolder{
    
22. private static Singleton instance = new Singleton();
    
23. }
    
24. private Singleton() {}//私有构造方法
    
25. 
    
26. public static Singleton getInstance() {
    
27. return SingletonHolder.instance;
    
28. }
    
29. 3. （1）Java的枚举类型实质上是功能齐全的类，因此可以有自己的属性和方法；（2）Java枚举类型的基本思想：通过公有的静态final域为每个枚举常量导出实例的类；（3）从某个角度讲，枚举是单例的泛化，本质上是单元素的枚举。
    
30. <P>public enum Singleton{
    
31. uniqueInstance;/*定义一个枚举元素，它就代表了Singleton的一个实例*/
    
32. /*实例方法，单例可以有自己的操作*/
    
33. public void singletonOperation(){
    
34. //Todo...
    
35. }
    
36. }

复制代码

赞个兄弟，，咱头像，，，呵呵

谢谢分享，受教了

额。。貌似。。。。。。。。。

收下了，谢谢分享

不错，继续加油

谢谢分享，总算知道枚举和单例设计模式的关系了

谢谢分享

非常不错啊

不错不错 学习了