单例模式总结

单例模式总结

通过网上视频的学习，总结了各种单例模式的实现。望多多指教。

1、懒汉式

class Singleton{
    private static Singleton instance;
    //构造方法私有化
    private Singleton(){
    }
    //提供一个静态的公有方法，
    public static Singleton getInstance(){
        if(instance==null){
            instance=new Singleton();
        }
        return instance;
    }
}

优点：起到了懒加载的效果
缺点：
1、只能单线程使用
2、在多线程的情况下，一个线程进入if判断语句，还没来得及往
下执行，另一个线程也通过了，判断语句，这样会产生多个实例。

2、饿汉式

    class Singleton{
        //构造器私有化，外部不能new
        private Singleton(){
        }
        //本类创建对象实例
        private static Singleton instance=new Singleton();
        public static Singleton getInstance(){
            return instance;
        }
}

优点：类装载的时候就完成实例化，避免了线程同步问题（多线程安全）
缺点：如果从始至终没有使用过，会造成内存的浪费。

3、懒汉式（线程安全，同步方法）

class Singleton{
    private static Singleton singleton;
    private Singleton(){};
    //提供了一个静态的公有方法，加入同步处理，解决了线程安全问题
    public static synchronized Singleton getSingleton(){
        if(singleton==null){
            singleton=new Singleton();
        }
        return singleton;
    }
}

优点：懒汉模式通过加synchronized锁，实现了多线程安全
缺点：效率太低，每个线程在想获得类时，执行getInstance（）方法都要加锁，

4、饿汉式（静态代码块）

class Singleton{
    //构造器私有化
    private Singleto(){
    }
    private static Singleton singleton;
    static {//在静态代码块中，创建单例对象
        singleton=new Singleton();
    }
    public static Singleton getSingleton() {
        return singleton;
    }
}

优点：类实例化的过程放在静态代码块，类装载时候，就的执行静态代码块，初始化类的实例。
缺点：可能造成内存浪费

5、双重校验锁机制

描述：单例双重检查（推荐使用）
线程安全，效率较高，开发中常用

class Singleton{
//volatile保证了可见性
    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;
    }
}

优点：
1.多线程安全，通过两次if(singleton==null）检查，保证了线程的安全性。
2.实例化代码只执行一次
3.延迟加载，效率较高

6、静态内部类

推荐使用

class Singleton{
    private Singleton(){}
    //写一个静态内部类，该类中有一个静态属性
    private static class SingletonIntance{
        private static Singleton instance=new Singleton();
    }
    public static Singleton getInstance(){
        return SingletonIntance.instance;
    }
}

采用类装载的机制来保证了初始化实例时只有一个线程
静态内部类方式在Singleton类装载时并不会立即实例化，
而是需要实例化时，调用getInstance()，才会装载SingletonIntance
从而完成SIngleton的实例化
类的静态属性只会在第一次加载类的时候初始化，JVM帮助我们保证了线程安全

7、枚举

推荐使用

enum Singleton{
    INSTANCE;//属性
    public void sing(){
	}
}

优点：不仅能够避免多线程同步问题，而且还能防止反序列化重新创建对象。