单例模式的前世今生（演绎）

最新推荐文章于 2024-10-16 10:13:45 发布

隔壁老王ing

最新推荐文章于 2024-10-16 10:13:45 发布

阅读量248

点赞数

分类专栏：单例文章标签： java 设计模式多线程

本文链接：https://blog.csdn.net/WGBLW/article/details/106717999

版权

单例专栏收录该内容

1 篇文章 0 订阅

订阅专栏

逐步演绎单例模式从性能差—>高，线程不安全–>安全的演绎

一：单例模式

缺点：不能懒加载，性能较差

/**
 * @Author wangcaiming
 * @Date 2020/6/12 15:21
 * @Version 1.0
 * @Description  单例    缺点：不能懒加载
 */
public class SingletonObject1 {
    private static final SingletonObject1 instance = new SingletonObject1();

    private SingletonObject1(){

    }

    public static SingletonObject1 getInstance(){
        return instance;
    }

}

二：单例模式

缺点：线程不安全

/**
 * @Author wangcaiming
 * @Date 2020/6/12 15:21
 * @Version 1.0
 * @Description  单例    缺点：线程不安全
 */
public class SingletonObject2 {
   private  static SingletonObject2  singletonObject2;
   private SingletonObject2(){

   }
   public static SingletonObject2 getInstance(){
       if(null == singletonObject2)
           singletonObject2 = new SingletonObject2();
       return singletonObject2;
   }
}

三：单例模式

缺点：同步类锁慢

/**
 * @Author wangcaiming
 * @Date 2020/6/12 15:21
 * @Version 1.0
 * @Description  单例    缺点：慢
 */
public class SingletonObject3 {
   private static SingletonObject3 singletonObject3;
   private SingletonObject3(){

   }
   private synchronized static SingletonObject3 getInstance(){
       if(null == singletonObject3){
           singletonObject3 = new SingletonObject3();
       }
       return singletonObject3;
   }
}

四：单例模式

缺点：命令重排序

/**
 * @Author wangcaiming
 * @Date 2020/6/12 15:21
 * @Version 1.0
 * @Description  单例    缺点：命令重排序
 */
public class SingletonObject4 {
   private static SingletonObject4 singletonObject4;
   private SingletonObject4(){

   }
   private static SingletonObject4 getInstance(){
       if(null == singletonObject4){
           synchronized (SingletonObject4.class){
               if(null == singletonObject4)
                   singletonObject4 = new SingletonObject4();
           }
       }
       return singletonObject4;
   }
}

五：单例模式

加了volatile ，保证可见性，有序性

/**
 * @Author wangcaiming
 * @Date 2020/6/12 15:21
 * @Version 1.0
 * @Description  单例
 */
public class SingletonObject5 {
    //volatile 保证可见性，有序性
   private volatile static SingletonObject5 singletonObject5;
   private SingletonObject5(){

   }
   private static SingletonObject5 getInstance(){
       if(null == singletonObject5){
           synchronized (SingletonObject5.class){
               if(null == singletonObject5)
                   singletonObject5 = new SingletonObject5();
           }
       }
       return singletonObject5;
   }
}

六：单例模式（推荐）

/**
 * @Author wangcaiming
 * @Date 2020/6/12 15:21
 * @Version 1.0
 * @Description  单例  推荐
 */
public class SingletonObject6 {
    private SingletonObject6(){

    }

    public static class InstanceHolder{
        private final static SingletonObject6 instance = new SingletonObject6();
    }

    public static SingletonObject6 getInstance(){
        return InstanceHolder.instance;
    }
}

七：单例模式（推荐）

/**
 * @Author wangcaiming
 * @Date 2020/6/12 15:21
 * @Version 1.0
 * @Description  单例  推荐
 */
public class SingletonObject7 {
    private SingletonObject7(){

    }

    private enum Singleton{
        INSTANCE;

        private final SingletonObject7 instance;

        Singleton(){
            instance = new SingletonObject7();
        }

        public SingletonObject7 getInstance(){
            return  instance;
        }
    }

    public static SingletonObject7 getInstance(){
        return Singleton.INSTANCE.getInstance();
    }
    
	//测试
    public static void main(String[] args) {
        IntStream.rangeClosed(1,100).forEach(i->new Thread(()->{
            System.out.println(SingletonObject7.getInstance());
        }).start());
    }
}