黑马程序员技术交流社区

标题: 关于单例设计模式中的懒汉式和饿汉式的区别?? [打印本页]

作者: Ф福@ 御    时间: 2014-5-20 20:06
标题: 关于单例设计模式中的懒汉式和饿汉式的区别??
两者的特点以及在什么场合使用??

求大神支招

作者: 李维奥    时间: 2014-5-20 23:05
当我们需要在内存中生成唯一对象时就可以用单例。比如说要向同一个银行账户存钱,取钱,这个就可以用单例。
饿汉式在对象一初始化就创建对象,而懒汉是在判断对象为空时才创建对象。
一般建议使用饿汉式,因为没有线程同步问题。懒汉式存在同步问题,有可能在线程抢占资源时重复创建对象,
解决方法就是加上同步代码块。

作者: 雨落千木的时节    时间: 2014-5-20 23:09
饿汉式:上来就new 一个实例,懒汉式:用到时才new一个实例
懒汉式存在死锁问题,若解决了死锁问题,效率就会比较低
写程序时建议使用饿汉式
作者: 寻找人生目标    时间: 2014-5-21 00:06
二楼正解     其实从恶汉式和懒汉式这名字上就能看出来
作者: Jero    时间: 2014-5-21 00:13
是饿汉,哈哈 不过看情况而定了。 对内存方面要求的话不知道怎么使用。
作者: ID1003    时间: 2014-5-21 00:35
来学习一下
作者: Ф福@ 御    时间: 2014-5-21 12:50
谢谢了,学习了,自己还是有很多不足
作者: 艮昕辶    时间: 2014-5-21 13:26
都是getInstance()获取对象
饿汉式是在
private Single instance=null;
getInstance(){
instance=new Single();
return instance;
}
懒汉式是在
private Single instance=new Single();
public Single getInstance(){
return instance;
}
作者: wangleixhlm    时间: 2014-5-21 13:32
一般提倡使用饿汉式,因为线程安全
作者: 黑马粉、峥    时间: 2014-5-21 22:40
饿汉是来什么吃什么,二话不说直接建立一个对象。懒汉是等有人用它了 才建立对象
作者: chenzhiyuan    时间: 2014-6-3 03:25
懒汉式不安全,第一次加载慢,因为要new对象,建议用饿汉式,保证只有一个实例对象,
作者: 淡淡柠檬茶    时间: 2014-6-3 12:48
饿汉式:先初始化对象
懒汉式:对象是方法被调用时才初始化,也叫做对象的延时加载

饿汉式类一加载就存在了;懒汉式类一加载就为null(调用方法的时候才在内存中建立对象)
饿汉式:Single类一进内存,就已经创建好了对象,
懒汉式:Single类进内存,对象还没有存在,只有调用方法时才建立对象

作者: 、海    时间: 2014-6-14 09:42
学习一下
作者: 爨庚轩    时间: 2014-6-14 20:58
学习了,说的很清楚啊

作者: DxxD    时间: 2015-3-10 10:40
视频貌似有讲啊:)
作者: 张红兴    时间: 2015-4-6 00:51
学习一下!
作者: 嘎嘎鸭子    时间: 2015-5-23 23:57
单例设计模式的作用:使一个类在内存中只存在一个对象。
我们知道,既然在内存中有且只有一个对象,我们知道构造方法可以创建对象,那么产生一个对象的前提即让构造方法私有化,不让外部访问。这样只能在内部访问,外部不可访问,既然是单个对象,则是类名直接调用,所以其中变量应该被static。那么我来详细概述下单例设计模式的细节。
单例设计模式实现步骤:
①将构造函数初始化。
例如:private Single(){}
②在类中创建一个本类对象。
例如:private static Single s= newSingle();
③提供一个访问方法可以获取到该对象。
例如:public static Single getInstance()
                             {
                                 return s ;
                        }
好了,罗嗦了这么多,我们还是看看如何用代码实现单例的细节吧!

单例设计模式有两种表现形式:
①“饿汉式”
②“懒汉式”
我们先来看看传说中的饿汉式:
public class Single
{
        private Single(){}//构造方法私有化
        private static Single instance = new Single();//实例化对象
        public static Single getInstance()
        {
                return instance;//暴露方法返回instance的对象
        }
}
饿汉式的特点:创建对象的同时就直接实例化对象。
那我们在看看“懒汉式”:
public class Single
{
        private Single(){}//构造方法私有化
        private static Single instance = null;
        public static Single getInstance()
        {
                if (instance==null)//这里判断看instance是否为空
                {
                        instance = new Single();//对象为空,实例化对象
                }
                return instance;//返回对象
        }
}
懒汉式的特点:方法被加载时才进行初始化操作,“懒汉式”又被称为延迟加载设计模式。
仔细观察,懒汉式的代码是有弊端的,我们来看看。
当多线程访问懒汉式时,因为懒汉式的方法内对共性数据进行多条语句的操作。所以容易出现线程安全问题。
class Single
{
        private static Single s = null;
        private Single(){}

        public static Single getInstance()
        { // 锁是谁?字节码文件对象;
                if (s == null)//该处判断是减少判断,增加效率
                {
                        synchronized (Single.class)//保证线程安全
                        {
                                if (s == null)//判断对象是否为空
                                        s = new Single();//实例化对象
                        }
                }
                return s;//返回变量
        }
}
上面加了几处判断,我们来分析下:
① s==null 是为了减少判断,增加效率
②synchronized (Single.class)为了保证线程安全
③if (s == null)是为了判断对象是否为空
为了解决,加入同步机制,解决安全问题。但是却带来了效率降低。所以我们不建议使用“懒汉式”,饿汉式简单高效,安全。

好了,到这里,我们的单例设计模式也基本接近尾声了,发现对于单例的解读也不是非常难,本身设计模式的目的就是为了方便编程才有了它的用武之地,所以设计模式掌握了其本质,也不会有那种“高大上”的阴影啦,好了,我们继续加油吧!

作者: guohuaxin    时间: 2015-6-16 19:39
写的不错啊
作者: Juice.cy.wang    时间: 2015-11-29 00:10
饿汉式,懒汉式。都是只创建一个对象,只是懒汉式有延时性。
作者: tribbianiwang    时间: 2015-12-8 19:31
都是大神啊,学习了
作者: Id_820    时间: 2015-12-9 20:34
围观哦。。。。。。
作者: 刀郎去西藏    时间: 2015-12-27 23:26
什么都没写好失望
作者: 11210107    时间: 2016-3-14 12:13
本帖最后由 11210107 于 2016-3-14 12:21 编辑

饿汉式与懒汉式的区别主要在于创建实例的位置不同,饿汉式在类内部(方法外)创建,懒汉式在方法中创建实例(可能存在线程安全问题)。
饿汉式(简化)
public class Singleton {
        
        //1、私有化构造器
        private Singleton(){
               
        }
        //2、创建类的实例
        private static Singleton singleton = new Singleton();
        //3、提供公共的方法来返回实例
        public static Singleton getInstance(){
                return singleton;
        }
        
}
懒汉式(简化):
public class Singleton{
        //私有化构造器
        private Singleton(){
               
        }
        //声明类的实例
        private static Singleton instance = null;
        //创建公共的方法返回实例
        public static Singleton getInstance(){               
                if(instance == null){
                        return new Singleton();
                }
                return instance;
        }
}

作者: bitwdh    时间: 2016-7-1 20:41
11210107 发表于 2016-3-14 12:13
饿汉式与懒汉式的区别主要在于创建实例的位置不同,饿汉式在类内部(方法外)创建,懒汉式在方法中创建实例 ...

好好收藏它,谢谢你分享....
作者: wz529377283    时间: 2016-7-10 23:48
饿汉式:类一加载,对象就会被创建.
懒汉式:对象的延时加载,只有方法被调用,对象才会被创建




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2