单例模式

/**
 * 此方法虽然不是最好的实现方式，但是是最常用的单例实现方式。
 * 因为是类一开始即被装载，故不用担心线程安全的问题。
 * 缺点：造成内存浪费
 */
public class Singleton1 {
    //类装载的时候已经实例化了
    private final static Singleton1 instance = new Singleton1();
    //私有化构造器
    private Singleton1(){

    }
    //提供共有的获取方法
    public static Singleton1 getInstance(){
        return instance;
    }

}

/**
 * 双重检查写法
 * 通过声明volatile和双重加锁的方式实现了单例模式。
 * 内部加一层判断，其实在考虑多线程同时进入了第一层 if判断中时，都在等待着锁的释放，
 * 但是释放之后其他线程已经进入了第一层，那么单例模式的结构就会被打乱了，
 * 其实锁也可以加在方法上，只不过锁的粒度问题，节省了一点内存。
 */
public class Singleton2 {

    //volatile声明作用是内存变量共享作用
    private static volatile Singleton2 instance;
    private Singleton2(){}

    //提供公有的获取方法
    public static Singleton2 getInstance(){
        if (instance == null){
            synchronized (Singleton2.class){
                if (instance == null){
                    instance = new Singleton2();
                }
            }
        }
        return instance;
    }
}

/**
 * 静态内部类实现
 *
 */
public class Singleton3 {

    private Singleton3(){}
    //静态内部类不会再一开始被装载，所以没有内存消耗问题
    //JVM在装载静态内部类是线程安全的，只有在使用内部类才会去装载，所以线程是安全的
    private static class SingletonInstance{
        private static final Singleton3 instance = new Singleton3();

    }
    //提供静态共有获取方法
    public static synchronized Singleton3 getInstance(){
        return SingletonInstance.instance;
    }
}

 

标签：private,instance,static,模式,单例,Singleton2,Singleton1,public
来源： https://blog.csdn.net/qq_32295155/article/details/102775956