java单例模式详解（懒汉模式，饿汉模式，双重检查加锁模式）

java单例模式详解（懒汉模式，饿汉模式，双重检查加锁模式）

1、概念

单例模式（Singleton Pattern），是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例。
通过概念我们可以总结出一个单例模式必须满足两点，第一保证一个类只有一个实例，第二提供一个访问它的全局访问点。而保证类唯一最好的方法就是让类自身负责保存他的唯一实例，同时还要确保这个类无法被其它实例创建。

2、常见应用场景

1.操作系统的任务管理器（Task Manager），因为同一台电脑无法同时打开两个任务管理器界面。
2.程序的日志系统，因为如果同时有两个程序维护日志文件，日志内容无法追加。
3.部分网站的访问量统计也采用单利模式，不然数据同步容易出问题。
4.web应用中配置文件的读取，因为配置文件是共享资源，非单例会创建多个相同的资源对象浪费系统内存、CPU等的性能。
5.垃圾回收机制。
6.线程池和连接池的实现。
…
以上可以看出，单例模式的应用场景：
共享资源的访问使用单例，如配置信息、日志信息等，避免建立多个相同的对象浪费系统资源
控制资源的访问使用单例，如线程池、连接池等，方便对于访问的资源进行控制。

3、实例（饿汉模式）

饿汉模式：

/**
 * Created by zhoust on 2019/2/24.
 * 单例模式-饿汉模式
 */
public class SingletonTest {
    private static SingletonTest instance = new SingletonTest();
    private String pt = "单例模式测试输出";
    //构造方法的私有化
    private SingletonTest(){

    }
    //全局访问方法
    public static SingletonTest getInstance(){
        return instance;
    }

    public String getPt() {
        return pt;
    }

    public void setPt(String pt) {
        this.pt = pt;
    }
}


public class Main {

    public static void main(String[] args) {
        SingletonTest test1 = SingletonTest.getInstance();
        SingletonTest test2 = SingletonTest.getInstance();
        System.out.println("单例模式-饿汉模式测试输出："+test1.getPt());
        if(test1 == test2){
            System.out.println("两个对象是同一个实例");
        }
    }
}

运行结果：

单例模式-饿汉模式测试输出：单例模式测试输出
两个对象是同一个实例

分析：
代码中构造方法SingletonTest()的私有化为了保证此类无法被其他实例创建，即堵死了外部类利用new来创建此实例的可能：

//构造方法的私有化
private SingletonTest(){

}

方法getInstance()是为了提供此唯一实例的全局访问点，定义为public static即无需实例化即可调用：

//全局访问方法
public static SingletonTest getInstance(){
    return instance;
}

属性instance即我们需要的唯一实例，声明为private static，因为静态方法getInstance()里只能调用静态变量，同时私有防止外部类进行更改：

private static SingletonTest instance = new SingletonTest();

4、其他常见的几种单例模式（懒汉模式、双重锁定懒汉模式）

在实例中我已经举出了一种常见的单例模式即饿汉模式，下面我将给出其他几种单例模式的实现：
懒汉模式：

/**
 * Created by zhoust on 2019/2/24.
 */
public class SingletonTest {
    private static SingletonTest instance;
    private String pt = "单例模式测试输出";
    //构造方法的私有化
    private SingletonTest(){

    }
    //全局访问方法
    public static SingletonTest getInstance(){
        if(instance == null){
            instance = new SingletonTest();
        }
        return instance;
    }

    public String getPt() {
        return pt;
    }

    public void setPt(String pt) {
        this.pt = pt;
    }
}

public class Main {

    public static void main(String[] args) {
        SingletonTest test1 = SingletonTest.getInstance();
        SingletonTest test2 = SingletonTest.getInstance();
        System.out.println("单例模式-懒汉模式测试输出："+test1.getPt());
        if(test1 == test2){
            System.out.println("两个对象是同一个实例");
        }
    }
}

输出结果：

单例模式-懒汉模式测试输出：单例模式测试输出
两个对象是同一个实例

分析：
此模式在懒汉模式下单例类的初始化是在调用getInstance()的时候完成的，而饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了，在饿汉模式下类一加载就实例化对象，所以需要提前占用系统的资源。而懒汉模式虽然在一定程度上节约了一部分系统资源，但是在多线程访问getInstance()方法，会有可能创建多个实例，造成线程不安全。为了解决懒汉模式多线程不安全问题—双重锁定懒汉模式
双重锁定懒汉模式

import java.util.concurrent.locks.Lock;

/**
 * Created by zhoust on 2019/2/24.
 */
public class SingletonTest {
    private static SingletonTest instance;

    private String pt = "单例模式测试输出";
    //构造方法的私有化
    private SingletonTest(){

    }
    //全局访问方法
    public static SingletonTest getInstance(){
        if(instance == null){
            synchronized (SingletonTest.class){
                if(instance == null){
                    instance = new SingletonTest();
                }
            }
        }
        return instance;
    }

    public String getPt() {
        return pt;
    }

    public void setPt(String pt) {
        this.pt = pt;
    }
}

public class Main {

    public static void main(String[] args) {
        SingletonTest test1 = SingletonTest.getInstance();
        SingletonTest test2 = SingletonTest.getInstance();
        System.out.println("单例模式-双重锁定懒汉模式测试输出："+test1.getPt());
        if(test1 == test2){
            System.out.println("两个对象是同一个实例");
        }
    }
}

运行结果

单例模式-双重锁定懒汉模式测试输出：单例模式测试输出
两个对象是同一个实例

分析：
这段代码中对象实例由最先进入的那个线程创建，以后线程在进入时不会再创建对象实例，由于有了synchronized保证了多个线程同时访问也不会有多了实例生成。先判断实例是否存在是为了我保证实例不存在的时候再进行加锁处理，这样能够节约一部分的系统资源。第二次的是否存在判断是为保证当instance为null的时多个线程同时调用的时候，他们都可以通过第一重判断，如果没有synchronized内的第二重判断会生成多个实例。