Java设计模式--单例模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

单例模式有八种方式

1. 饿汉式（静态变量）  
2. 饿汉式（静态代码块）  
3. 懒汉式（线程不安全）  
4. 懒汉式（线程安全，同步方法）  
5. 懒汉式（线程安全，同步代码块）  
6. 双重检查  
7. 静态内部类  
8. 枚举

1. 饿汉式（静态变量）

package cn.org.design.singleton01;

/**
 * @Author: PurcellHuang
 * @Date: 2019-08-18 23:41
 * 饿汉式(静态变量)
 */
public class Singleton01 {

    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println(singleton);
        Singleton s = Singleton.getInstance();
        System.out.println(s);
    }
}
class Singleton{
    private Singleton(){}
    private final static Singleton singleton = new Singleton();
    public static Singleton getInstance(){
        return singleton;
    }
}

缺点：
没有延迟加载，类初始化时创建，会造成内存空间浪费。

2. 饿汉式（静态代码块）

package cn.org.design.singleton02;

/**
 * @Author: PurcellHuang
 * @Date: 2019-08-18 23:41
 * 饿汉式(静态代码块)
 */
public class Singleton02 {

    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println(singleton);
        Singleton s = Singleton.getInstance();
        System.out.println(s);
    }
}
class Singleton{
    private Singleton(){}
    private static Singleton singleton ;
    static {
        singleton = new Singleton();
    }
    public static Singleton getInstance(){
        return singleton;
    }
}

缺点：
没有延迟加载，类初始化时创建，会造成内存空间浪费。

3. 懒汉式（线程不安全）

package cn.org.design.singleton03;

/**
 * @Author: PurcellHuang
 * @Date: 2019-08-18 23:41
 * 懒汉式(线程不安全)
 */
public class Singleton03 {

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

    public static Singleton getInstance(){
        if (singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

优点：
懒加载，需要用时创建。
缺点：
线程不安全。

4. 懒汉式（线程安全，同步方法）

package cn.org.design.singleton04;

/**
 * @Author: PurcellHuang
 * @Date: 2019-08-18 23:41
 * 懒汉式(线程安全,同步方法)
 */
public class Singleton04 {

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

    public static synchronized Singleton getInstance(){
        if (singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

优点：
懒加载，需要用时创建，线程安全。
缺点：
运行较慢。

5. 懒汉式（线程安全，同步代码块）

package cn.org.design.singleton05;

/**
 * @Author: PurcellHuang
 * @Date: 2019-08-18 23:41
 * 懒汉式(线程安全,同步代码块)
 */
public class Singleton05 {

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

class Singleton{
    private Singleton(){}
    private static volatile Singleton singleton ;

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

    }
}

优点：
懒加载，需要用时创建，线程安全。
缺点：
运行较慢。

6. 双重检查

package cn.org.design.singleton06;

/**
 * @Author: PurcellHuang
 * @Date: 2019-08-18 23:41
 * 懒汉式(线程安全，双重检查)
 */
public class Singleton06 {

    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println(singleton);
        Singleton s = Singleton.getInstance();
        System.out.println(s);
    }
}
class Singleton{
    private Singleton(){}
    private static volatile Singleton singleton ;

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

    }
}

优点：
懒加载，需要用时创建，线程安全。推荐使用。

7. 静态内部类

package cn.org.design.singleton07;

/**
 * @Author: PurcellHuang
 * @Date: 2019-08-18 23:41
 * 懒汉式(线程安全,静态内部类)
 */
public class Singleton07 {

    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println(singleton);
        Singleton s = Singleton.getInstance();
        System.out.println(s);
    }
}
class Singleton{
    private Singleton(){}
    private static class Instance{
        private static Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance(){
        return Instance.INSTANCE;

    }
}

优点：
懒加载，需要用时创建，线程安全。推荐使用。

8. 枚举

package cn.org.design.singleton08;

/**
 * @Author: PurcellHuang
 * @Date: 2019-08-19 10:32
 * 枚举
 */
public class Singleton08 {
    public static void main(String[] args) {
        Singleton s1 = Singleton.INSTANCE;
        Singleton s2 = Singleton.INSTANCE;
        System.out.println(s1==s2);
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
    }
}
enum Singleton{
    INSTANCE;
}

优点：
线程安全。自动支持序列化机制，绝对防止多次实例化。推荐使用。