单例模式讲解

来源：互联网发布：最新版软件开发合同编辑：程序博客网时间：2024/06/04 18:58

单例模式中有懒汉式和饿汉式两种，具体些发可以参见以下的代码

饿汉式：

/饿汉式单例类.在类初始化时，已经自行实例化   
public class Singleton1 {  
    private Singleton1() {}  
    private static final Singleton1 single = new Singleton1();  
    //静态工厂方法   
    public static Singleton1 getInstance() {  
        return single;  
    }  
}

饿汉式在类创建的时候就创建了一个静态的类对象供系统使用，所以是线程安全的。

线程安全概念？

如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

或者说：一个类或者程序所提供的接口对于线程来说是原子操作，或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题，那就是线程安全的。

懒汉式：

    //懒汉式单例类.在第一次调用的时候实例化自己   
    public class Singleton {  
        private Singleton() {}  
        private static Singleton single=null;  
        //静态工厂方法   
        public static Singleton getInstance() {  
             if (single == null) {    
                 single = new Singleton();  
             }    
            return single;  
        }  
    }

但是这种写法没有考虑到线程安全性问题，所以要解决线程安全性问题，可以通过以下三种方法：

1.在getInstance方法上加同步

    public static synchronized Singleton getInstance() {  
             if (single == null) {    
                 single = new Singleton();  
             }    
            return single;  
    }

2.双重检查锁定

    public static Singleton getInstance() {  
            if (singleton == null) {    
                synchronized (Singleton.class) {    
                   if (singleton == null) {    
                      singleton = new Singleton();   
                   }    
                }    
            }    
            return singleton;   
        }

3.静态内部类

    public class Singleton {    
        private static class LazyHolder {    
           private static final Singleton INSTANCE = new Singleton();    
        }    
        private Singleton (){}    
        public static final Singleton getInstance() {    
           return LazyHolder.INSTANCE;    
        }    
    }

这种比上面1、2都好一些，既实现了线程安全，又避免了同步带来的性能影响。

下面以懒汉式为例，写一个例子：

    public class TestSingleton {  
        String name = null;  
      
            private TestSingleton() {  
        }  
      
        private static volatile TestSingleton instance = null;  
      
        public static TestSingleton getInstance() {  
               if (instance == null) {    
                 synchronized (TestSingleton.class) {    
                    if (singleton == null) {    
                       singleton = new TestSingleton();   
                    }    
                 }    
               }   
               return instance;  
        }  
      
        public String getName() {  
            return name;  
        }  
      
        public void setName(String name) {  
            this.name = name;  
        }  
      
        public void printInfo() {  
            System.out.println("the name is " + name);  
        }  
      
    }

可以看到代码中使用了关键字Volatile，具体原因如下所示：

假设没有关键字volatile的情况下，两个线程A、B，都是第一次调用该单例方法，线程A先执行instance = new Instance()，该构造方法是一个非原子操作，编译后生成多条字节码指令，由于JAVA的指令重排序，可能会先执行instance的赋值操作，该操作实际只是在内存中开辟一片存储对象的区域后直接返回内存的引用，之后instance便不为空了，但是实际的初始化操作却还没有执行，如果就在此时线程B进入，就会看到一个不为空的但是不完整（没有完成初始化）的Instance对象，所以需要加入volatile关键字，禁止指令重排序优化，从而安全的实现单例。

如果一个基本变量被volatile修饰，编译器将不会把它保存到寄存器中，而是每一次都去访问内存中实际保存该变量的位置上。这一点就避免了没有 volatile修饰的变量在多线程的读写中所产生的由于编译器优化所导致的灾难性问题。所以多线程中必须要共享的基本变量一定要加上volatile修饰符。当然了，volatile还能让你在编译时期捕捉到非线程安全的代码

0 0