文章目录

• 单例模式总结
• • 1、懒汉式
  • 2、饿汉式
  • 3、懒汉式（线程安全，同步方法）
  • 4、饿汉式（静态代码块）
  • 5、双重校验锁机制
  • 6、静态内部类
  • 7、枚举

单例模式总结

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

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(){
	}
}
           

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