JAVA中单例设计模式详解与实现方式

单例模式的定义

单例设计模式，也成为Singleton，属于软件开发过程中最常用的设计模式。

单：唯一

例：实例

从字面上理解，就是在整个软件或系统中，某个类只能存在一个实例对象能够被获取和使用。

代表例子：JVM运行环境中的Runtime类。

特点：

1、某个类只能存在一个实例。——构造器要私有化。

2、必须自行创建该实例。——必须有一个该类的静态变量来保存这个唯一的实例。

3、整个系统中能够访问到该实例。——对外提供访问该实例的方式，可以直接获取，也可以通过类的静态方法get获取。

常见实现方式

常见的单例实现模式可以分为饿汉式和懒汉式。

饿汉式：在类初始化时，就会创建该实例。

懒汉式：在需要该实例的时候，才会创建该实例。

饿汉式实现方式：

1、直接实例化（简单直观）

public class Singleton1{
    //这里使用private修饰，将构造器私有化。
    //使用static设置为静态，使得该实例在类加载时就创建。
    //为了提供对外的访问，因此将权限修饰为public，使得外界可以直接访问到该实例
    public static final Singleton1INSTANCE = new Singleton1();
    private Singleton1(){
    }
}

接下来进行测试，直接创建singleton1的实例

public class test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Singleton1 s1 = Singleton1.INSTANCE;
        Singleton1 s2 = Singleton1.INSTANCE;
        System.out.println(s1==s2);
        System.out.println(s1);
        System.out.println(s2);

由于是静态，因此可以直接通过类名调用该实例，那么得到的结果为：

true
Singleton1@16b98e56
Singleton1@16b98e56

2、枚举类型实现（简洁）

java中的枚举类型，代表着该类型的对象是有限的，在这里我们可以定义只有一个对象，那么此时的代码就十分的简洁

public enum Singleton2 {
    INSTANCE
}

 接下来进行测试

Singleton2 s1 = Singleton2.INSTANCE;
Singleton2 s2 = Singleton2.INSTANCE;
System.out.println(s1==s2);
System.out.println(s1);
System.out.println(s2);

true
INSTANCE
INSTANCE

这里打印的时候会显示INSTANCE，与上面稍有不同，但是实现的依然是单例模式。

3、静态代码块饿汉式（适用于复杂实例化）

这种情况下，只是多了一个静态代码块，来单独实例化该对象。

public class Singleton3 {
    public static final Singleton3 INSTANCE;

    static{
        INSTANCE = new Singleton3();
    }

    private Singleton3(){
    }
}

测试方法：

Singleton3 s1 = Singleton3.INSTANCE;
Singleton3 s2 = Singleton3.INSTANCE;
System.out.println(s1==s2);
System.out.println(s1);
System.out.println(s2);

true
Singleton3@16b98e56
Singleton3@16b98e56

该类方法相较于第一种方法的好处是，如果实例化时，需要传入一些参数，参数又是通过文件保存的，那么可以在这个静态代码块中完成较为复杂的操作，比如先加载文件，读取文件中的数据，然后再传入私有构造方法实例化。

懒汉式实现方法

1、线程不安全创建（适用于单进程）

public class Singleton4 {
    static Singleton4  instance;

    private Singleton4(){

    }
    public static Singleton4 getInstance(){
        if(instance==null){
            instance = new Singleton4();
        }
        return instance;
    }
}

 主要思路：

（1）仍旧是私有化构造函数。

（2）该实例仍为static修饰，设置为静态实例。

（3）通过设置一个public类型的get方法，只有当调用该类的该方法时候，才会创建并返回，或返回该实例。

测试：

Singleton4 instance = Singleton4.getInstance();
Singleton4 instance2 = Singleton4.getInstance();
System.out.println(instance==instance2);
System.out.println(instance);
System.out.println(instance2);

结果为：

true
Singleton4@16b98e56
Singleton4@16b98e56

 该方法为什么是线程不安全，这里用多线程创建两个线程，都调用该类的getInstance静态方法，那么有可能存在这样的情况，两个方法并不是顺序执行，同时发现instance为NULL，这时候两个线程就都会创建实例，并返回，就会生产两个实例。

Callable<Singleton4> c = new Callable<Singleton4>() {
    @Override
    public Singleton4 call() throws Exception {
        return Singleton4.getInstance();
    }
};
//创建线程池，大小为2
ExecutorService es = Executors.newFixedThreadPool(2);
Future<Singleton4> f1 = es.submit(c);
Future<Singleton4> f2 = es.submit(c);
Singleton4 instance1 = f1.get();
Singleton4 instance2 = f2.get();
System.out.println(instance1==instance2);
System.out.println(instance1);
System.out.println(instance2);
//关闭线程池
es.shutdown();

这时候可以看到，结果就会出现两个不同的实例

false
Singleton4@12edcd21
Singleton4@34c45dca

2、线程安全创建（适用于多进程）

为了解决多线程的单例模式，保证该实例唯一。

public class Singleton5 {
    private static Singleton5 instance;
    private Singleton5(){

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

 注意，这里用stychronized来将代码块做一个包围。其余没有变化，从而保证实例化唯一。

        Callable<Singleton5> c = new Callable<Singleton5>() {

            @Override
            public Singleton5 call() throws Exception {
                return Singleton5.getInstance();
            }
        };
        ExecutorService es = Executors.newFixedThreadPool(2);
        Future<Singleton5> f1 = es.submit(c);
        Future<Singleton5> f2 = es.submit(c);
        Singleton5 instance = f1.get();
        Singleton5 instance2 = f2.get();
        System.out.println(instance==instance2);
        System.out.println(instance);
        System.out.println(instance2);

true
Singleton5@12edcd21
Singleton5@12edcd21

3、静态内部类形式（适用于多进程）

最后一种是使用静态内部类，这里首先私有化构造函数，然后定义一个静态内部类，Inner，在内部类中定义Singleton6类的实例。同时设置外部类的getInstance()方法，返回静态内部类中定义的Instance实例。

public class Singleton6 {
    private Singleton6() {
    }
    private static class Inner{
        private static final Singleton6 Instance = new Singleton6();
    }
    public static Singleton6 getInstance(){
        return Inner.Instance;
    }

}

        Singleton6 instance = Singleton6.getInstance();
        Singleton6 instance2 = Singleton6.getInstance();
        System.out.println(instance==instance2);
        System.out.println(instance);
        System.out.println(instance2);

true
Singleton6@7ef20235
Singleton6@7ef20235