Java单例模式

前文叙述

单例模式概念：确保一个类有且只有一个实例，并且提供一个全局访问点来访问这个唯一实例。简单一点说就是只对外提供一个 static 修饰的公共方法返回这个类的唯一实例化对象，避免了每次都 new 一个新对象。

文章参考 java_tutorial.pdf 电子书。

方式一：饿汉式

实现思路：

1、将构造器私有化

2、声明一个 static 修饰的字段存储类的实例化对象，提供一个 static 实例化的公共方法返回这个单例类对象

// File Name: Singleton.java
public class Singleton {
    // 一开始就实例化对象，就比如一个人很饿，一上来就要吃饭，
    private static Singleton singleton = new Singleton( );

    /* A private Constructor prevents any other
* class from instantiating.
*/
    private Singleton(){ }

    /* Static 'instance' method */
    public static Singleton getInstance( ) {
        return singleton;
    }
    /* Other methods protected by singleton-ness */
    protected static void demoMethod( ) {
        System.out.println("demoMethod for singleton");
    }
}

使用时用类名点出来，这样便可实现一个单例对象

// File Name: SingletonDemo.java
public class SingletonDemo {
    public static void main(String[] args) {
        Singleton tmp = Singleton.getInstance( );
        tmp.demoMethod( );
    }
}

方式二：懒汉式

方法一：线程不安全。

实现思路：

同样是将构造器私有化，不同的是懒汉式是需要的时候才创建实例化对象（也叫延迟实例化对象），ClassicSingleton 方法在第一次调用之前都不会创建实例化对象。

public class ClassicSingleton {
    private static ClassicSingleton instance = null;
    private ClassicSingleton() {
        // Exists only to defeat instantiation.
    }
    public static ClassicSingleton getInstance() {
        // 使用的时候才实例化对象
        if(instance == null) {
            instance = new ClassicSingleton();
        }
        return instance;
    } }

方式二：懒汉式，线程安全-synchronized

synchronized 是重量级安全锁，通常用于修饰静态方法和代码块。使用 synchronized 关键字修饰的静态方法或静态代码块一次只能有一个线程访问，因此可解决并发的安全问题，从而实现数据同步。

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

方法三：线程安全-双检锁/双重校验锁（DCL，即 double-checked locking）

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