Java 设计模式之Singleton~~

在lintcode上找到这么一道题，很莫名其妙，可是非科班出身的自己还是有点糊涂。

http://www.lintcode.com/en/problem/singleton/

题目如下。

Singleton is a most widely used design pattern. If a class has and only has one instance at every moment, we call this design as singleton. For example, for class Mouse (not a animal mouse), we should design it in singleton.

You job is to implement a getInstance method for given class, return the same instance of this class every time you call this method.

Have you met this question in a real interview? 

Yes

Example

In Java:

A a = A.getInstance();
A b = A.getInstance();

a should equal to b.

Challenge

If we call getInstance concurrently, can you make sure your code could run correctly?

意思很简单，就是java里面的单例设计模式。

中文如下。

单例 是最为最常见的设计模式之一。对于任何时刻，如果某个类只存在且最多存在一个具体的实例，那么我们称这种设计模式为单例。例如，对于 class Mouse (不是动物的mouse哦)，我们应将其设计为 singleton 模式。

你的任务是设计一个 getInstance 方法，对于给定的类，每次调用 getInstance 时，都可得到同一个实例。

AC代码如下

class Solution {
    /**
     * @return: The same instance of this class every time
     */
    private static Solution instance = null; 
    public static Solution getInstance() {
        // write your code here
            if (instance == null)  
            instance = new Solution();  
        return instance; 
    }
};

采用的是饿汉模式，在类装载的时候进行构建，急切进行初始化。

------------------------------

Singleton模式

    宗旨：在于确保某个类只有一个实例，并且为之提供一个全局访问点，为了防止其他工作人员实例化我们的类。

    方法：为该类创建唯一一个构造器，并将构造器设置为私有。注意：如果我们创建了其他的非私有构造器，或者根本没有为该类提供构造器，那么其他人员仍然能够实例化我们的类。

    通常单例模式在Java语言中，有两种构建方式：

• 饿汉方式:指全局的单例实例在类装载时构建， 急切初始化。
• 懒汉方式:指全局的单例实例在第一次被使用时构建，延迟初始化。

1.饿汉式单例类

    采用饿汉式的写法可避免线程安全问题，但是任何对Singleton类的访问(内部的static final变量除外，因为jvm会把它们直接编译为常量)，比如类中有另外一个static方法被访问，将会引起jvm去初始化instance，而此时我们的本意是不想加载单例类的。同时又因为没有延迟加载，最明显的缺点就是如果构造器内的方法比较耗时，则加载过程会比较长。对于一般的应用，构造方法内的代码不涉及到读取配置、远程调用、初始化IOC容器等长时间执行的情况，用这种方式是最简单的。 

//饿汉式单例类  
public class Singleton1 {  
    private Singleton1(){}  
      
    //在自己内部定义自己一个实例，注意这是private 只供内部调用  
    private static Singleton1 instance = new Singleton1();  
      
    //这里提供了一个供外部访问本class的静态方法，可以直接访问　  
    public static Singleton1 getInstance() {  
        return instance;  
    }  
}  

2.懒汉式单例类

//懒汉式单例类  
public class Singleton2 {  
    private Singleton2() {  
    }  
      
    private static Singleton2 instance = null;  
  
    // 只是在第一次调用getInstance才生成对象，不受其他static方法影响！  
    public static Singleton2 getInstance() {  
        if (instance == null)  
            instance = new Singleton2();  
        return instance;  
    }  
}  

    以上懒汉单例中，单线程是没有问题的，但多线程时就会有可能出现两个或者以上的Singletion2实例的情况。 例如：线程1在判断instance==null为真，扫行new操作时，在执行new操作之前，判断为真之后，线程2正好执行判断操作，这时instance还为null.因此，线程2也会执行new操作。以此类推，在高并发下面，就可能存在两个或者以上的Singletion2的实例。

    因此修改代码如下：

public class Singleton3 {  
    private Singleton3() {  
    }  
  
    private static Singleton3 instance = null;  
  
    //为了多线程不出错，加入了同步标志  
    public static synchronized Singleton3 getInstance() {  
        if (instance == null)  
            instance = new Singleton3();  
        return instance;  
    }  
}  

     但getInstance会被外部线程比较频繁的调用，同步比非同步的性能消耗要昂贵很多，因此这样的做法会存在很大的额外性能消耗。因此产生如下的双重检查写法：

public class Singleton3 {  
    private Singleton3() {  
    }  
  
    private static Singleton3 instance = null;  
  
    public static Singleton3 getInstance() {  
        if (instance == null) {  
            synchronized (Singleton3.class) {  
                if (instance == null) {  
                    instance = new Singleton3();  
                }  
            }  
        }  
        return instance;  
    }  
}  

    此写法存在的问题在于singleton = new Singleton() 这句代码对于编译器来说，是分两步进行。首先初始化一个singleton对象并随意赋一个值，然后调用Singleton类的构造器赋值。因此在第一步完成后singleton == null这句判断已经不成立了，但此时singleton只是一个临时值。如果线程2此时进入getInstance，就会把这个singleton给返回出去。由于java的内存模型，双重检查并不能成功的起到作用。 

    如果我们既想使用延迟加载的好处，让类在被使用的时候才去加载，又想避免额外的同步调用开销，同时还不使用双重检查的模式，可以用初始化一个中间的容器类来解决这个问题，就可以用如下的写法： 

public class Singleton {  
    private static class SingletonHolder {  
        static Singleton instance = new Singleton();  
    }  
  
    public static Singleton getInstance() {  
        return SingletonHolder.instance;  
    }  
  
    private Singleton() {  
    }  
}  

     java中，只有一个类被用到的时候才被初始化。在getInstance方法被调用的时候，如果SingletonHolder类没有被加载，就会去加载，起到延迟加载的作用，同时也能保持多线程下的语义正确性。 

    如果是jdk1.5以上，还可采用enum方式来实现，也可避免多线程的问题。

 

enum Singleton4 {  
    INSTANCE;  
    public static Singleton4 getInstance() {  
        return INSTANCE;  
    }  
  
    public void test() {  
        System.out.println("test");  
    }  
} 

    引用来自：http://wangnn09.blog.163.com/blog/static/13625087320118532552725/