JavaSE：单例设计模式

一 什么是Singleton？

Singleton：在Java中即指单例设计模式，它是软件开发中最常用的设计模式之一；
单例设计模式，即某个类在整个系统中只能有一个实例对象可被获取和使用的代码模式；
例如：代表JVM运行环境的Runtime类。

二 要点

1 某个类只能有一个实例

构造器私有化

2 必须自行创建这个实例

含有一个该类的静态变量来保存这个唯一的实例

3 必须自行向整个系统提供这个实例

对外提供获取该实例对象的方式：
（1）直接暴露
（2）用静态变量的get方法获取

三 几种常见形式

1 饿汉式：直接创建对象，不存在程安全问题

（1）直接实例化饿汉式（简洁直观）

package com.single;
/**
 *   1 构造器私有化
 *   2 自行创建，并且用静态变量保存
 *   3 向外提供这个实例
 *   4 强调这是一个单例，用final修改
 */
public class Singleton1 {
    public static final Singleton1 INSTANCE = new Singleton1();
    private Singleton1(){

    }
}

测试：

package com.test;

import com.single.Singleton1;

public class TestSington1 {
    public static void main(String[] args) {
        Singleton1 s = Singleton1.INSTANCE;
        System.out.println(s);
    }
}

测试结果：

（2）枚举式（最简洁）

package com.single;
/**
 *   枚举类型：表示该类型的对象是有限的几个
 *   我们可以限定为一个，就成了单例
 */
public enum Singleton2 {
    INSTANCE;
}

测试：

package com.test;

import com.single.Singleton2;

public class TestSingleton2 {
    public static void main(String[] args) {
        Singleton2 s = Singleton2.INSTANCE;
        System.out.println(s);
    }
}

测试结果：

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

package com.single;

import java.io.IOException;
import java.util.Properties;

public class Singleton3 {
    public static final Singleton3 INSTANCE;
    private String info;

    static{
        try{
            Properties properties = new Properties();
            properties.load(Singleton3.class.getClassLoader().getResourceAsStream("single.properties"));
            INSTANCE = new Singleton3(properties.getProperty("info"));
        }catch (IOException e){
            throw new RuntimeException(e);
        }
    }

    private Singleton3(String info){
        this.info = info;
    }

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return "Singleton3{" +
                "info='" + info + '\'' +
                '}';
    }
}

single.properties文件：

info="gcsyzy"

测试：

package com.test;

import com.single.Singleton3;

public class TestSingleton3 {
    public static void main(String[] args) {
        Singleton3 s = Singleton3.INSTANCE;
        System.out.println(s);
    }
}

测试结果：

2 懒汉式：延迟创建对象

（1）线程不安全（适用于单线程）

package com.single;

/**
 *   1 构造器私有化
 *   2 用一个静态变量保存这个唯一实例
 *   3 提供一个静态方法，获取这个实例对象
 */
public class Singleton4 {
    private static Singleton4 instance;

    private Singleton4(){

    }

    public static Singleton4 getInstance(){
        // 判断instance是否为空，若为空则创建这个实例
        if (instance == null){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            instance = new Singleton4();
        }
        return instance;
    }
}

测试：

package com.test;

import com.single.Singleton4;

import java.util.concurrent.*;

public class TestSingleton4 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Singleton4> c = new Callable<Singleton4>() {
            @Override
            public Singleton4 call() throws Exception {
                return Singleton4.getInstance();
            }
        };
        // 创建两个线程任务
        ExecutorService es = Executors.newFixedThreadPool(2);
        Future<Singleton4> f1 = es.submit(c);
        Future<Singleton4> f2 = es.submit(c);

        Singleton4 s1 = f1.get();
        Singleton4 s2 = f2.get();

        System.out.println(s1 == s2);
        System.out.println(s1);
        System.out.println(s2);
        // 关闭服务
        es.shutdown();
    }
}

测试结果：有两种结果，存在线程安全问题
结果1：

结果2：

（2）线程安全（适用于多线程）

package com.single;

/**
 *   1 构造器私有化
 *   2 用一个静态变量保存这个唯一实例
 *   3 提供一个静态方法，获取这个实例对象
 */
public class Singleton5 {
    private static Singleton5 instance;

    private Singleton5(){

    }

    public static Singleton5 getInstance(){
        // 同步，保障线程安全
        synchronized (Singleton5.class){
            // 判断instance是否为空，若为空则创建这个实例
            if (instance == null){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                instance = new Singleton5();
            }
        }
        return instance;
    }
}

测试：

package com.test;

import com.single.Singleton5;
import java.util.concurrent.*;

public class TestSingleton5 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        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 s1 = f1.get();
        Singleton5 s2 = f2.get();

        System.out.println(s1 == s2);
        System.out.println(s1);
        System.out.println(s2);
        // 关闭服务
        es.shutdown();
    }
}

测试结果：

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

package com.single;

/**
 *   在内部类被加载和初始化时，才创建INSTANCE实例对象
 *   静态内部类不会自动随着外部类的加载和初始化而初始化，它是要单独去加载和初始化的。
 *   因为是在内部类加载和初始化是创建的，因此是线程安全的
 */
public class Singleton6 {
    private Singleton6(){

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

测试：

package com.test;

import com.single.Singleton6;

public class TestSingleton6 {
    public static void main(String[] args) {
        Singleton6 s = Singleton6.getInstance();
        System.out.println(s);
    }
}

测试结果：

四 小结

• 如果是饿汉式，枚举形态最简单
• 如果是懒汉式，静态内部类形式最简单