Singleton模式即单例模式，故名思意，单例模式会确保任何情况下都绝对只有一个实例，当我们想在程序中表示某个东西只会存在一个的时候，那么就需要单例模式。

示例程序

Singleton 类

public class Singleton {
    private static Singleton singleton = new Singleton();

    // 构造器是私有的，无法使用new生成实例
    private Singleton() {
        System.out.println("生成了一个实例");
    }

    public static Singleton getInstance() {
        return singleton;
    }
}

Main 类

public class Main {
    public static void main(String[] args){
        Singleton obj1 = Singleton.getInstance();
        Singleton obj2 = Singleton.getInstance();
        if(obj1 == obj2){
            System.out.println("obj1 与 obj2 是相同的实例");
        }else{
            System.out.println("obj1 与 obj2 是不同的实例");
        }
    }
}

运行结果如下：

生成了一个实例
obj1 与 obj2 是相同的实例

Singleton 模式中的角色

Singleton

Singleton模式中只有Singleton这一个角色；Singleton角色中有一个返回实例的static方法，该方法总是会返回同一个实例。

UML

对Singleton模式的思考

单例模式的作用

单例模式的作用其一是为了解决多线程并发访问的问题。
例如：一个系统中可以存在多个预执行任务，但是只能有一个正在工作的任务。例如示例程序：

public class TicketMaker {
    private int ticket = 1000;
    private static TicketMaker ticketMaker = new TicketMaker();
    private TicketMaker(){

    }
    public static TicketMaker getInstance(){
        return ticketMaker;
    }

    public synchronized int getNextTicketNumber(){
        return ticket++;
    }
}

上述程序中，我们只希望生成一个TicketMaker实例，并且能够让getNextTicketNumber在多线程的环境下正常工作，所以我们需要将其定义为synchronized方法。

单例模式的作用其二是为了节约系统的内存，提高系统运行的效率,如果对于一种工具类，你需要频繁调用，如果每次调用都要产生新的实例，那么就会在浪费内存的空间，所以单例模式的一个优点就是减少资源消耗，并且能提高程序的运行速度。

一个问题

有单例模式如下：

public class Singleton1 {
    private static Singleton1 singleton1 = null;
    private Singleton1(){
        
    }
    public static Singleton1 getInstance(){
        if(singleton1 == null){
            singleton1 = new Singleton1();
        }
        return singleton1;
    }
}

为什么上述程序不是严格的Singleton模式 ?
答案：因为在多线程几乎同时调用Singleton.getInstance方法的时候，可能会生成多个实例。
首先将程序改动一下,降低一下处理速度：

public class Singleton1 {
    private static Singleton1 singleton1 = null;
    private Singleton1(){
        try {
            Thread.sleep(1000);
        }catch (InterruptedException e){

        }
    }
    public static Singleton1 getInstance(){
        if(singleton1 == null){
            singleton1 = new Singleton1();
        }
        return singleton1;
    }

}

在多线程的环境下，进行程序的测试：

public class Main extends Thread{
    public Main(String name){
        super(name);
    }

    public void run(){
        Singleton1 obj = Singleton1.getInstance();
        System.out.println(getName() + ": obj = " + obj);
    }

    public static void main(String[] args){
        new Main("A").start();
        new Main("B").start();
        new Main("C").start();
    }
}

程序运行的结果为:

C: obj = DesignMode.Singleton.Singleton1@5c13df07
B: obj = DesignMode.Singleton.Singleton1@50564e5e
A: obj = DesignMode.Singleton.Singleton1@5b1a5c4a

可以看到产生了多个不同的实例，为什么会出现这种情况呢？
原因在于，在多线程的环境下，使用如下代码

if(singleton == null){
    singleton = new Singleton();
}

进行判断是线程不安全的，如果在使用singleton == null 判断了第一个实例是否为空后，执行了语句，但是在赋值之前，其他的线程也在进行singleton == null的判断，继而创建出了不同的实例。那么如何修改本程序呢？
修改结果如下：

public synchronized static Singleton1 getInstance(){
        if(singleton1 == null){
            singleton1 = new Singleton1();
        }
        return singleton1;
    }

将getInstance变为 synchronized方法即可。对于这种单例模式：

public class Singleton1 {
    private static Singleton1 singleton1 = null;
    private Singleton1(){
        try {
            Thread.sleep(1000);
        }catch (InterruptedException e){

        }
    }
    public synchronized static Singleton1 getInstance(){
        if(singleton1 == null){
            singleton1 = new Singleton1();
        }
        return singleton1;
    }
}

我们称之为懒汉式单例模式，而最开始的那种单例模式则是饿汉式。两者的优缺点为饿汉式为线程安全，调用效率高，但是不能延时加载；懒汉式线程安全，但是因为 getInstance方法为synchronized,所以调用效率不高，但是可以延时加载。其实还有更好的实现单例模式的方法，比如：静态内部类实现单例模式：

public class Singleton2 {
    private static class SingletonClassInstance {
        private static final Singleton2 instance = new Singleton2();
    }

    private Singleton2() {
    }

    public static Singleton2 getInstance() {
        return SingletonClassInstance.instance;
    }
}

这种实现线程安全，调用效率高，并且可以做到延时加载。