java——单例模式详细总结

单例模式详细总结

一、饿汉式两种方式

1、静态变量直接new出来

package com.gykalc.jdk8.singleton.type01;

public class SingletonTest01 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        System.out.println(singleton == singleton1);
        System.out.println("singleton HashCode: " + singleton.hashCode());
        System.out.println("singleton1 HashCode: " + singleton1.hashCode());
    }
}

/**
 * 单例模式之饿汉式方式一
 * 优点：通过类加载机制，实现了线程安全的单例模式
 * 缺点：不管有没有用到该对象，都会创建其实例，浪费内存
 */
class Singleton {
    private static final Singleton instance = new Singleton();
    private Singleton() {}

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

2、静态代码块new出来

package com.gykalc.jdk8.singleton.type02;

public class SingletonTest01 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        System.out.println(singleton == singleton1);
        System.out.println("singleton HashCode: " + singleton.hashCode());
        System.out.println("singleton1 HashCode: " + singleton1.hashCode());
    }
}

/**
 * 单例模式之饿汉式方式二
 * 优点：通过类加载机制，实现了线程安全的单例模式
 * 缺点：不管有没有用到该对象，都会创建其实例，浪费内存
 */
class Singleton {
    private static final Singleton instance;
    static {
        instance = new Singleton();
    }
    private Singleton() {}

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

二、懒汉式两种方式

1、单线程模式

package com.gykalc.jdk8.singleton.type03;

public class SingletonTest01 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        System.out.println(singleton == singleton1);
        System.out.println("singleton HashCode: " + singleton.hashCode());
        System.out.println("singleton1 HashCode: " + singleton1.hashCode());
    }
}

/**
 * 单例模式之懒汉式方式一
 * 优点：在调用getInstance方法时，才会创建实例并返回，节约内存空间
 * 缺点：只适用于单线程，多线程导致会产生多个不同的对象，不推荐使用
 */
class Singleton {
    private static Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

2、支持多线程

package com.gykalc.jdk8.singleton.type04;

public class SingletonTest01 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        System.out.println(singleton == singleton1);
        System.out.println("singleton HashCode: " + singleton.hashCode());
        System.out.println("singleton1 HashCode: " + singleton1.hashCode());
    }
}

/**
 * 单例模式之懒汉式方式二
 * 优点：在调用getInstance方法时，才会创建实例并返回，节约内存空间，并通过Synchronized实现线程安全
 * 缺点：每次调用getInstance都是同步的，导致效率特别低，不推荐使用
 */
class Singleton {
    private static Singleton instance;
    private Singleton() {}
    public static synchronized Singleton getInstance() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

双重检查

package com.gykalc.jdk8.singleton.type05;

public class SingletonTest01 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        System.out.println(singleton == singleton1);
        System.out.println("singleton HashCode: " + singleton.hashCode());
        System.out.println("singleton1 HashCode: " + singleton1.hashCode());
    }
}

/**
 * 单例模式之双重检查
 * 优点：也是相当于懒汉式，只是通过双重检查实现线程安全，并且只要创建了对象之后，getInstance就不是同步方法了。效率提高了
 * 可以使用
 */
class Singleton {
    private static volatile Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

静态内部类方式

package com.gykalc.jdk8.singleton.type06;

public class SingletonTest01 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        System.out.println(singleton == singleton1);
        System.out.println("singleton HashCode: " + singleton.hashCode());
        System.out.println("singleton1 HashCode: " + singleton1.hashCode());
    }
}

/**
 * 单例模式之静态内部类
 * 优点：通过静态内部类加载机制，实现线程安全和懒加载，效率高
 * 推荐使用
 */
class Singleton {

    private Singleton() {}

    public static Singleton getInstance() {
        return SingletonFactory.getInstance();
    }

    private static class SingletonFactory {
        private static final Singleton instance = new Singleton();
        public static Singleton getInstance() {
            return instance;
        }
    }

}

枚举方式

package com.gykalc.jdk8.singleton;

public class SingletonTest01 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.INSTANCE;
        Singleton singleton1 = Singleton.INSTANCE;
        System.out.println(singleton == singleton1);
        System.out.println("singleton HashCode: " + singleton.hashCode());
        System.out.println("singleton1 HashCode: " + singleton1.hashCode());
    }
}

/**
 * 单例模式之枚举
 * 优点：通过枚举类实现单例模式，支持线程安全、效率高特别推荐
 * 大神强烈推荐使用
 */
enum Singleton {
    INSTANCE;
}