精华内容
下载资源
问答
  • 懒汉

    2008-05-20 11:54:00
    懒汉,天下第一懒人,都不在网上写东西的 转载于:https://www.cnblogs.com/rboc/archive/2008/05/20/1203247.html
    懒汉,天下第一懒人,都不在网上写东西的

    转载于:https://www.cnblogs.com/rboc/archive/2008/05/20/1203247.html

    展开全文
  • 懒汉模式

    2020-09-05 16:10:37
    单例模式之懒汉模 双重校验锁 //懒汉模式,不提前加载instance对象到JVM的堆新生代区域 public class Singleton { //私有化构造方法,不要外部创建单例 private Singleton(){}; //准备好instance对象===>...

    单例模式

    1. 单例模式之懒汉模 双重校验锁
    //懒汉模式,不提前加载instance对象到JVM的堆新生代区域
    public class Singleton {
        
        //私有化构造方法,不要外部创建单例
        private Singleton(){};
        
        //准备好instance对象===>目前是null
        private static Singleton instance;
        
        //向外部提供获得对象的方法,static修饰为了用Singleton直接调用方法
        public static Singleton getInstance(){
            
            //双重校验,为了提高效率,上锁之前先判断是否已经有对象存在
            //如果有对象直接返回,不需要线程等待
            if(instance == null){
                
                //下面代码有线程安全问题,加锁
                synchronized (Singleton.class){
                    
                    //再次判断instance对象是否存在
                    if(instance == null){
                        
                        instance = new Singleton();
                        return instance;
                    }
                }
            }
            return instance;
        }
    }
    
    展开全文
  • 懒汉

    千次阅读 2019-04-11 18:07:10
    懒汉式单例懒汉式单例模式在第一次调用的时候进行实例化。 public class Singleton1 { private static Singleton1 instance = null; private Singleton1() { } /** * 1、适用于单线程环境(不推荐) */ ...


    懒汉式单例懒汉式单例模式在第一次调用的时候进行实例化。
     

    public class Singleton1 {
    
        private static Singleton1 instance = null;
    
        private Singleton1() {
        }
    
        /**
         * 1、适用于单线程环境(不推荐)
         */
        public static Singleton1 getInstanceA() {
            if (null == instance) {
                instance = new Singleton1();
            }
            return instance;
        }
    
        /**
         * 2、适用于多线程环境,但效率不高(不推荐)
         */
        public static synchronized Singleton1 getInstanceB() {
            if (instance == null) {
                instance = new Singleton1();
            }
            return instance;
        }
    
        /**
         * 3、双重检查加锁(推荐)
         */
        public static Singleton1 getInstanceC() {
            // 先判断实例是否存在,若不存在再对类对象进行加锁处理
            if (instance == null) {
                synchronized (Singleton1.class) {
                    if (instance == null) {
                        instance = new Singleton1();
                    }
                }
            }
            return instance;
        }
    }


    1、适用于单线程环境(不推荐)

    此方式在单线程的时候工作正常,但在多线程的情况下就有问题了。如果两个线程同时运行到判断instance是否为null的if语句,并且instance的确没有被创建时,那么两个线程都会创建一个实例,此时类型Singleton1就不再满足单例模式的要求了。
     

       public static Singleton1 getInstanceA() {
            if (null == instance) {
                instance = new Singleton1();
            }
            return instance;
        }
    }
    


    2、适用于多线程环境,但效率不高(不推荐)

    为了保证在多线程环境下我们还是只能得到该类的一个实例,只需要在getInstanceB()方法加上同步关键字sychronized,就可以了。但每次调用getInstanceB()方法时都被synchronized关键字锁住了,会引起线程阻塞,影响程序的性能。

    public static synchronized Singleton1 getInstanceB() {
            if (instance == null) {
                instance = new Singleton1();
            }
            return instance;
        }


    3、双重检验锁

    为了在多线程环境下,不影响程序的性能,不让线程每次调用getInstanceC()方法时都加锁,而只是在实例未被创建时再加锁,在加锁处理里面还需要判断一次实例是否已存在。
     

      public static Singleton1 getInstanceC() {
            // 先判断实例是否存在,若不存在再对类对象进行加锁处理
            if (instance == null) {
                synchronized (Singleton1.class) {
                    if (instance == null) {
                        instance = new Singleton1();
                    }
                }
            }
            return instance;
        }


    4、静态内部类方式(推荐)加载一个类时,其内部类不会同时被加载。一个类被加载,当且仅当其某个静态成员(静态域、构造器、静态方法等)被调用时发生。 由于在调用 StaticSingleton.getInstance() 的时候,才会对单例进行初始化,而且通过反射,是不能从外部类获取内部类的属性的;由于静态内部类的特性,只有在其被第一次引用的时候才会被加载,所以可以保证其线程安全性。 
    总结: 
    优势:兼顾了懒汉模式的内存优化(使用时才初始化)以及饿汉模式的安全性(不会被反射入侵)。 
    劣势:需要两个类去做到这一点,虽然不会创建静态内部类的对象,但是其 Class 对象还是会被创建,而且是属于永久带的对象。

    public class StaticSingleton {
        /**
         * 私有构造方法,禁止在其他类中创建实例
         */
        private StaticSingleton() {
        }
    
        /**
         * 获取实例
         */
        public static StaticSingleton getInstance() {
            return StaticSingletonHolder.instance;
        }
    
        /**
         * 一个私有的静态内部类,用于初始化一个静态final实例
         */
        private static class StaticSingletonHolder {
            private static final StaticSingleton instance = new StaticSingleton();
        }
    
        /**
         * 方法A
         */
        public void methodA() {
        }
    
        /**
         * 方法B
         */
        public void methodB() {
        }
    
        public static void main(String[] args) {
            StaticSingleton.getInstance().methodA();
            StaticSingleton.getInstance().methodB();
        }
    }
    


     

    展开全文
  • 单例 懒汉

    2019-07-16 16:37:30
    * description: 单例 懒汉 */ public class LazySingleton { private static LazySingleton lazySingleton; private LazySingleton(){ } //方法1和2选哪个都行 //方法一 public static ...

     

    /**
     * description: 单例 懒汉
     */
    
    public class LazySingleton {
        
        private static LazySingleton lazySingleton;
    
        private LazySingleton(){
    
        }
    
        //方法1和2选哪个都行
        //方法一
        public static synchronized LazySingleton getInstance(){
            if(lazySingleton == null){
                lazySingleton = new LazySingleton();
            }
            return lazySingleton;
        }
    
        //方法二
        public static LazySingleton getInstance(){
            synchronized (LazySingleton.class){
                if(lazySingleton == null){
                    lazySingleton = new LazySingleton();
                }
            }
            return lazySingleton;
        }
    }
    
    

    不足之处:性能 在多线程并发下这样的实现是无法保证实例唯一

    优化:DCL

    展开全文
  • 单例模式懒汉式和饿汉式区别

    万次阅读 多人点赞 2018-04-11 11:19:45
    单例模式懒汉式和饿汉式区别 单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 这种模式涉及到一个单一的类,该类负责创建...
  • 懒汉式单例演进到DCL懒汉式 深度全面解析本篇文章背景预期第一阶段:普通的懒汉式单例第二阶段:加锁懒汉式单例第三阶段:普通DCL懒汉式单例第四阶段:终极版DCL懒汉式单例小结 本篇文章背景 网上很多懒汉式单例模式...
  • Java 单例模式 懒汉模式 //懒汉式 多线程中不可以保证是一个对象
  • 饿汉模式和懒汉模式

    2018-07-03 11:13:19
    单例模式中,包括饿汉模式和懒汉模式,这是饿汉模式和懒汉模式的区别
  • 懒汉式单例

    2020-09-09 17:33:09
    比较安全的懒汉式单例 /** * 双重检查锁 */ public class Student{ pirvate Student(){} // 防止指令重排序,使student变的可见 private volatile static Student student; public static Student ...
  • 单例懒汉模式和饿汉模式,以及线程安全版懒汉模式 单例模式:是一种常见的设计模式,一个类只能创建出一个实例对象,这就是单例模式写法(封装)。 封装:就是对复杂事物的一种简化。可以说是对具有相同特征的一类...
  • 首先写一个单例的懒汉模式: package THREAD; /* * 懒汉模式*/ public class Sluggard { private static Sluggard instance =null; public Sluggard(){ } public static Sluggard Getintance(){ if(instance==...
  • 懒汉的旅行

    2019-01-23 18:51:48
    懒汉需要从A城市开车到B城市去见一个朋友,他的汽车的邮箱的容积L升,车每行驶1公里就要消耗1升油。途中只有在到达一个城市之后才可以找的到加油站并加油,而且懒汉的车很特殊,每次加油只能加满整个邮箱。 懒汉...
  • 单例懒汉线程安全

    2020-08-10 17:47:52
    懒汉线程安全
  • 懒汉式单例模式

    2021-05-07 22:28:25
    为了解决饿汉式单例模式,带来的内存占用问题,于是就出现了懒汉式单例的写法,懒汉式单例模式的特点是,单例对象要在被使用时才会初始化,下面看懒汉式单例模式的简单实现。 懒汉单例,在测试时可以将断点打在创建...
  • 饿汉式单例 浪费资源 /** * 饿汉式单例 * @author li */ public class Hungry { private Hungry() { } ... public final static Hungry ...懒汉式单例、双重检验锁懒汉式单例 双重检验锁懒汉式单例也不安全,可
  • 单例懒汉模式

    2021-05-24 13:55:18
    * 实现一个附带的 单例方法(懒汉模式) * * @description: TestService * @author: leimin * @date: 2021/5/24 13:50 */ public class TestService { public static TestService getInstance() { return ...
  • 单例懒汉

    2017-03-16 22:51:56
    单例懒汉
  • title: 懒汉、饿汉单例模式-完整的懒汉单例模式实现 date: 2019-06-07 23:22:50 tags: [设计模式,多线程] 本文主要介绍懒汉和饿汉单例模式实现以及多线线程场景下完整的懒汉单例模式的实现 一般实现 饿汉式单例...
  • 懒汉模式是一种思想,是一种开发程序的规范
  • 单例模式,目前看到,饿汉式,懒汉式,双重验证懒汉式,饿汉式static final object = new object() 当类加载的时候直接初始化,并且不可改变,私有化构造器,对外开放一个获取接口。 缺点,当单例对象过多时占用没有...
  • 懒汉式01

    2019-10-25 17:45:47
    * 懒汉式 * * 延迟创建这个实例对象 * * * 1.构造器私有化 * 2.用一个静态变量保存这个唯一的实例 * 3.提供一个静态方法,获取这个实例对象 * * * * @author chen * */ public class Singleton...
  • 单例设计模式(懒汉式与饿汉式以及懒汉式存在的问题) 学习内容: 单例设计模式: 核心思想:就是这个类,在程序的任何其他模块中,获取它的对象时,拿到的永远是同一个对象。 单例模式有两种写法:懒汉式和饿汉式...
  • 单例模式懒汉

    2020-05-01 21:28:00
    懒汉式:用的时候才创建对象 public class Teacher { private Teacher(){} private static Teacher t=null; //调用方法的时候再new Teacher(); //懒汉式有线程安全问题 //要加synchronized public ...
  • 懒汉单例模式

    2016-05-15 22:17:16
    单例设计模式---懒汉单例模式 能够保证在只有用它的时候才创建它的对象。 推荐使用饿汉单例模式,因为懒汉单例模式会存在线程安全问题, 目前还不能保证一个类在内存中只有一个对象。 懒汉单例模式设计步骤: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,093
精华内容 6,437
关键字:

懒汉