精华内容
下载资源
问答
  • java设计模式之单例模式——Singleton pattern
    2019-01-03 14:41:59

    设计模式故事会:https://blog.csdn.net/weixin_40205234/article/details/90664824

    单例模式

    单例模式(Singleton pattern)是java中最常见的设计模式之一。该模式属于创建型设计模式,它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一对象的方式,可以直接访问,不需要实例化该类的对象。

    注意:

    • 1.单例类只有一个实例。
    • 2.单例类必须自己创建自己唯一的实例。
    • 3.单例类必须给其他所有对象提供这一实例。

    一、介绍

    意图:保证一个类仅有一个实例,并提供一个访问它的全局访问点。

    主要解决:一个全局使用的类,频繁的创建与销毁。

    何时使用:当你想控制实例数量,节省系统资源的时候。

    如何解决:判断系统是否有这个单例,如果有则返回,没有则创建。

    关键代码:构造函数是私有的。

    应用场景:

    1. Windows的任务管理器(Task Manager)就是很典型的单例模式(熟悉吧,试试看自己能不能同时打开两个Task Manager)
    2. Windows的回收站(Recycle Bin)也是典型的单例模式。在整个系统运行中,回收站一直维护着仅有的一个实例。
    3. 网站计数器一般
    更多相关内容
  • 摘要:讨论Singleton设计模式(指示如何以及何时创建对象的创造性模式)及其在Microsoft.NET框架中的有效使用。内容简介Singleton模式结论简介在开发软件应用程序过程中,随着应用程序的开发,会出现重复性的模式。...
  • 单例模式(Singleton Pattern)是设计模式中最简单的模式之一,属于创建型模式。这种设计模式主要是类的对象只有一个实例,不需要每次new 创造。而我们要做的的就是确保这个对象创建的唯一。然后根据一些特征进行...
  • Singleton 设计模式

    2014-04-08 13:27:08
    Singleton 设计模式
  • java singleton 不解释不解释不解释不解释
  • 主要介绍了Java设计模式之单态模式(Singleton模式)介绍,本文讲解了如何使用单例模式、使用单例模式注意事项等内容,需要的朋友可以参考下
  • 主要介绍了C#设计模式中的Singleton模式相关知识,文中代码非常详细,供大家理解学习,感兴趣的朋友可以了解下
  • php /** * 单例模式 * * 保证一个类仅有一个实例,并提供一个访问它的全局访问点 * */ class Singleton { static private $_instance = null; private function __construct() { } static public function ...
  • 主要介绍了Java设计模式单例模式(Singleton)用法解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了单例模式 Singleton 简单实例设计模式解析的相关资料,需要的朋友可以参考下
  • 主要介绍了使用设计模式中的Singleton单例模式来开发iOS应用程序的例子,示例代码为传统的Objective-C语言,需要的朋友可以参考下
  • 如果某个类管理了系统中的某种资源,那么我们只能创建该类的一个实例,此时用到singleton设计模式(后面为了简化将省略“设计模式”四个字)比较合适了。然而,如果不注意实现方法,很有可能会让我们碰到一些...
  • JavaScript设计模式学习 Singleton
  • 设计模式之单例模式(Singleton)

    千次阅读 2021-11-19 15:08:07
    设计模式中有六大原则和二十三设计模式。 其中六大原则分别为:单一职责原则、开闭原则、里氏替换原则、依赖倒置原则、接口隔离原则、迪米特原则。 二十三设计模式:单例模式、Builder 模式、原型模式、工厂方法模式...

    设计模式中有六大原则和二十三设计模式。
    其中六大原则分别为:单一职责原则、开闭原则、里氏替换原则、依赖倒置原则、接口隔离原则、迪米特原则。
    二十三设计模式:单例模式、Builder 模式、原型模式、工厂方法模式、抽象工厂模式、策略模式、状态模式、责任链模式、解释器模式、命令模式、观察者模式、备忘录模式、迭代器模式、模版方法模式、访问者模式、中介模式、代理模式、组合模式、适配器模式、装饰模式、享元模式、外观模式、桥接模式。
    现在我们就介绍下单例模式(Singleton)。

    单例模式(Singleton)

    单例模式应该是我们开发中使用最多的一种设计模式,不管是资深的还是新手程序员,应该都用过它。

    定义

    一个类有且仅有一个实例,并且自行实例化向整个系统提供。

    使用场景

    确保某个类在项目中有且只有一个对象,避免产生过多的对象浪费资源。例如:

    • 工具类(时间转换、图片加载等)
    • 网络请求IO 操作等

    实现

    单例模式有很多实现方式,例如:

    • 懒汉式—线程不安全
    • 懒汉式—线程安全
    • 饿汉方式
    • 双检锁式
    • 登记式
    • 枚举

    懒汉式—线程不安全

    最基础的实现方式,线程上下文单例,不需要共享给所有线程,也不需要加synchronize之类的锁,以提高性能。

    • 示例
    /**
     * 单例模式
     */
    public class Singleton {
        private static Singleton instance;
        // 懒汉式—线程不安全
        public static Singleton getInstance1(){
            if (instance == null){
                instance = new Singleton();
            }
            return instance;
        }
    }
    

    然而它有个致命缺点,就是在两个相同的线程中同时调用了getInstance1() 时,就会在这两个线程中产生不同的Singleton 对象。单例的作用就相当没有了。由于它的线程不安全,所以有了下面的方式。

    懒汉式—线程安全

    加上synchronize之类保证线程安全的基础上的懒汉模式,相对性能很低,大部分时间并不需要同步。

    • 示例
    /**
     * 单例模式
     */
    public class Singleton {
        private static Singleton instance;
        // 懒汉式—线程安全
        public static synchronized Singleton getInstance2(){
            if (instance == null){
                instance = new Singleton();
            }
            return instance;
        }
    }
    

    这样写,它是线程安全了;但由于它是同步方法,在多线程调用它时,都会synchronized下,从而效率低下。在使用的过程中为了提高效率,所以我们有了如下方式

    饿汉方式

    指全局的单例实例在类装载时构建。它天生就是线程安全的。

    • 示例
    /**
     * 单例模式
     */
    public class Singleton {
        // 饿汉式
        private static Singleton instance2 = new Singleton();
        public static Singleton getInstance3(){
            return instance2;
        }
    }
    

    它是线程安全了,但是如果这个类我一直不使用,由于类初始化时,就已经实例它了,所以它会一直占着资源不释放。鉴于这种情况又有了如下方式。

    双检锁式

    在懒汉式基础上利用synchronize关键字和volatile关键字确保第一次创建时没有线程间竞争而产生多个实例,仅第一次创建时同步,性能相对较高

    • 示例
    /**
     * 单例模式
     */
    public class Singleton {
        // 双检锁式
        private static volatile Singleton instance3;
        public static Singleton getInstance3(){
            if (null == instance3){
                synchronized (Singleton.class){
                    if (null == instance3){
                        instance3 = new Singleton();
                    }
                }
            }
            return instance3;
        }
    }
    

    它是我们平时开发过程中使用单例模式最多的一种方式。它线程安全而且效率也提高了,但是它第一次加载时反应慢,偶尔也会加载失败。在高并发下也会有一些缺陷,虽然概率很小。为了优化它,出现了如下的方式。

    登记式

    作为创建类的全局属性存在,创建类被装载时创建。

    • 示例
    /**
     * 单例模式
     */
    public class Singleton {
    
        // 登记式
        public static Singleton getInstance4(){
            return SingletonHolder.instance;
        }
        private static class SingletonHolder{
            private static final Singleton instance = new Singleton();
        }
    }
    

    当第一次记载Singleton 时并不会初始化instance,只有第一次调用getInstance4()时才会实例化。它不仅保证线程安全、也能保证对象的唯一性,同时也延迟了单例的实例化。so 它也是最为推荐的一种单例模式
    这种也叫做静态内部类单例模式。还有一种是容器式单例模式

    • 示例
    /**
     * 单例模式
     */
    public class Singleton {
        // 登记式-容器式单例模式
        private static Map<String, Object> singletonMap = new HashMap<String, Object>();
        public static Object getInstance5(Class clazz) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
            String className = clazz.getName();
            if (ObjectUtils.isEmpty(className)){
                className = Singleton.class.getName();
            }
            if (!singletonMap.containsKey(className) || null == singletonMap.get(className)){
                singletonMap.put(className, (Singleton)Class.forName(className).newInstance());
            }
            return singletonMap.get(className);
        }
    }
    

    以上这种方式,可以把多种单例类型放到统一的一个map 中管理,降低了我们使用的成本。也对用户隐藏了具体实现。降低耦合度。
    最后在说下枚举单例

    枚举

    java中枚举类本身也是一种单例模式。最重要的是枚举实例的创建是线程安全的,并且在任何情况下他都是一个单例。

    • 示例
    /**
     * 枚举单例
     */
    public enum SingletonEnum {
        INSTANCE;
        public void method(){
            System.out.println("singleton");
        }
    }
    public static void main(String[] args) {
        SingletonEnum.INSTANCE.method();
    }
    

    这个方式使用的很少,但是它真的很好用,不需要担心序列化和反序列化的问题。如果是其他单例反序列化时,需要增加一个readResolve() 的函数,返回单例实例。

        private Object readResolve(){
            return instance;
        }
    

    readResolve() 是反序列化提供的钩子函数。防止单例在反序列化时再重新new 一个新的对象。

    总结

    单例模式在我们开发中是经常用到的一种设计模式,使用哪种方式的单例,我们应该根据实际的需求去选型,而不是一味的跟风。了解更多的设计模式才能写出优雅的代码。
    demo

    参考:
    百度百科-单例模式
    《Android 源码设计模式解析与实践》

    展开全文
  • singleton设计模式,c++实现

    千次阅读 2012-08-04 20:44:31
    singleton设计模式就是实现对象只能new一次   #include class base { private: base() { // std::cout; str = "hello world"; // me = NULL; } public: char* str; priv

           singleton设计模式就是实现对象只能new一次

           

    #include <iostream>
    
    class base
    {
    	private:
    		base()
    		{
    			//	std::cout<<"hello world"<<std::endl;
    			str = "hello world";
    			//	me = NULL;
    		}
    	public:
    		char* str;
    	private:
    		static base* me;
    	public:
    		static base* GetInstance()
    		{
    			if(me == NULL)
    			{
    				me = new base();
    
    			}
    			return me;
    		}
    		void hello()
    		{
    			std::cout<<"hello world"<<std::endl;
    		}
    	public:
    		void _delete()
    		{
    			std::cout<<"bye"<<std::endl;
    			delete me;
    			me = NULL;
    		}
    		~base()
    		{
    			;
    		}
    };
    base* base::me = NULL;
    int main()
    {
    	base* me = base::GetInstance();
    	me->hello();
    	me->_delete();
    	return 0;
    }



    展开全文
  • java设计模式,单例模式的不同实现方式
  • 深入浅出单实例Singleton设计模式

    千次阅读 2016-04-25 22:48:10
    单实例Singleton设计模式可能是被讨论和使用的最广泛的一个设计模式了,这可能也是面试中问得最多的一个设计模式了。这个设计模式主要目的是想在整个系统中只能出现一个类的实例。这样做当然是有必然的,比如你的...

    原作者:haoel(陈皓

    来源:http://blog.csdn.net/haoel/article/details/4028232


    单实例Singleton设计模式可能是被讨论和使用的最广泛的一个设计模式了,这可能也是面试中问得最多的一个设计模式了。这个设计模式主要目的是想在整个系统中只能出现一个类的实例。这样做当然是有必然的,比如你的软件的全局配置信息,或者是一个Factory,或是一个主控类,等等。你希望这个类在整个系统中只能出现一个实例。当然,作为一个技术负责人的你,你当然有权利通过使用非技术的手段来达到你的目的。比如:你在团队内部明文规定,“XX类只能有一个全局实例,如果某人使用两次以上,那么该人将被处于2000元的罚款!”(呵呵),你当然有权这么做。但是如果你的设计的是东西是一个类库,或是一个需要提供给用户使用的API,恐怕你的这项规定将会失效。因为,你无权要求别人会那么做。所以,这就是为什么,我们希望通过使用技术的手段来达成这样一个目的的原因。

    本文会带着你深入整个Singleton的世界,当然,我会放弃使用C++语言而改用Java语言,因为使用Java这个语言可能更容易让我说明一些事情。


    Singleton的教学版本

    这里,我将直接给出一个Singleton的简单实现,因为我相信你已经有这方面的一些基础了。我们姑且把这个版本叫做1.0版


    在上面的实例中,我想说明下面几个Singleton的特点:(下面这些东西可能是尽人皆知的,没有什么新鲜的)

    1. 私有(private)的构造函数,表明这个类是不可能形成实例了。这主要是怕这个类会有多个实例。

    2. 即然这个类是不可能形成实例,那么,我们需要一个静态的方式让其形成实例:getInstance()。注意这个方法是在new自己,因为其可以访问私有的构造函数,所以他是可以保证实例被创建出来的。

    3. 在getInstance()中,先做判断是否已形成实例,如果已形成则直接返回,否则创建实例。

    4. 所形成的实例保存在自己类中的私有成员中。

    5. 我们取实例时,只需要使用Singleton.getInstance()就行了。

    当然,如果你觉得知道了上面这些事情后就学成了,那得给你当头棒喝一下了,事情远远没有那么简单。


    Singleton的实际版本

    上面的这个程序存在比较严重的问题,因为是全局性的实例,所以,在多线程情况下,所有的全局共享的东西都会变得非常的危险,这个也一样,在多线程情况下,如果多个线程同时调用getInstance()的话,那么,可能会有多个进程同时通过 (singleton== null)的条件检查,于是,多个实例就创建出来,并且很可能造成内存泄露问题。嗯,熟悉多线程的你一定会说——“我们需要线程互斥或同步”,没错,我们需要这个事情,于是我们的Singleton升级成1.1版,如下所示:


    嗯,使用了Java的synchronized方法,看起来不错哦。应该没有问题了吧?!错!这还是有问题!为什么呢?前面已经说过,如果有多个线程同时通过(singleton== null)的条件检查(因为他们并行运行),虽然我们的synchronized方法会帮助我们同步所有的线程,让我们并行线程变成串行的一个一个去new,那不还是一样的吗?同样会出现很多实例。嗯,确实如此!看来,还得把那个判断(singleton== null)条件也同步起来。于是,我们的Singleton再次升级成1.2版本,如下所示:


    不错不错,看似很不错了。在多线程下应该没有什么问题了,不是吗?的确是这样的,1.2版的Singleton在多线程下的确没有问题了,因为我们同步了所有的线程。只不过嘛……,什么?!还不行?!是的,还是有点小问题,我们本来只是想让new这个操作并行就可以了,现在,只要是进入getInstance()的线程都得同步啊,注意,创建对象的动作只有一次,后面的动作全是读取那个成员变量,这些读取的动作不需要线程同步啊。这样的作法感觉非常极端啊,为了一个初始化的创建动作,居然让我们达上了所有的读操作,严重影响后续的性能啊!

    还得改!嗯,看来,在线程同步前还得加一个(singleton== null)的条件判断,如果对象已经创建了,那么就不需要线程的同步了。OK,下面是1.3版的Singleton。



    感觉代码开始变得有点罗嗦和复杂了,不过,这可能是最不错的一个版本了,这个版本又叫“双重检查”Double-Check。下面是说明:

    1. 第一个条件是说,如果实例创建了,那就不需要同步了,直接返回就好了。

    2. 不然,我们就开始同步线程。

    3. 第二个条件是说,如果被同步的线程中,有一个线程创建了对象,那么别的线程就不用再创建了。

    相当不错啊,干得非常漂亮!请大家为我们的1.3版起立鼓掌!

    但是,如果你认为这个版本大攻告成,你就错了。

    主要在于singleton = new Singleton()这句,这并非是一个原子操作,事实上在 JVM 中这句话大概做了下面 3 件事情。

    1. 给 singleton 分配内存

    2. 调用 Singleton 的构造函数来初始化成员变量,形成实例

    3. 将singleton对象指向分配的内存空间(执行完这步 singleton才是非 null 了)

    但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的,最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者,则在 3 执行完毕、2 未执行之前,被线程二抢占了,这时 instance 已经是非 null 了(但却没有初始化),所以线程二会直接返回 instance,然后使用,然后顺理成章地报错。

    对此,我们只需要把singleton声明成 volatile 就可以了。下面是1.4版:


    使用 volatile 有两个功用:

    1)这个变量不会在多个线程中存在复本,直接从内存读取。

    2)这个关键字会禁止指令重排序优化。也就是说,在 volatile 变量的赋值操作后面会有一个内存屏障(生成的汇编代码上),读操作不会被重排序到内存屏障之前。

    但是,这个事情仅在Java 1.5版后有用,1.5版之前用这个变量也有问题,因为老版本的Java的内存模型是有缺陷的。


    Singleton 的简化版本

    上面的玩法实在是太复杂了,一点也不优雅,下面是一种更为优雅的方式:

    这种方法非常简单,因为单例的实例被声明成 static 和 final 变量了,在第一次加载类到内存中时就会初始化,所以创建实例本身是线程安全的。


    但是,这种玩法的最大问题是——当这个类被加载的时候,new Singleton() 这句话就会被执行,就算是getInstance()没有被调用,类也被初始化了。

    于是,这个可能会与我们想要的行为不一样,比如,我的类的构造函数中,有一些事可能需要依赖于别的类干的一些事(比如某个配置文件,或是某个被其它类创建的资源),我们希望他能在我第一次getInstance()时才被真正的创建。这样,我们可以控制真正的类创建的时刻,而不是把类的创建委托给了类装载器


    好吧,我们还得绕一下:

    下面的这个1.6版是老版《Effective Java》中推荐的方式。


    上面这种方式,仍然使用JVM本身机制保证了线程安全问题;由于 SingletonHolder 是私有的,除了 getInstance() 之外没有办法访问它,因此它只有在getInstance()被调用时才会真正创建;同时读取实例的时候不会进行同步,没有性能缺陷;也不依赖 JDK 版本。


    Singleton 优雅版本

    1

    2

    3

    publicenum Singleton{

       INSTANCE;

    }

    居然用枚举!!看上去好牛逼,通过EasySingleton.INSTANCE来访问,这比调用getInstance()方法简单多了。

    默认枚举实例的创建是线程安全的,所以不需要担心线程安全的问题。但是在枚举中的其他任何方法的线程安全由程序员自己负责。还有防止上面的通过反射机制调用私用构造器。

    这个版本基本上消除了绝大多数的问题。代码也非常简单,实在无法不用。这也是新版的《Effective Java》中推荐的模式。


    Singleton的其它问题

    怎么?还有问题?!当然还有,请记住下面这条规则——“无论你的代码写得有多好,其只能在特定的范围内工作,超出这个范围就要出Bug了”,这是“陈式第一定理”,呵呵。你能想一想还有什么情况会让这个我们上面的代码出问题吗?

    在C++下,我不是很好举例,但是在Java的环境下,嘿嘿,还是让我们来看看下面的一些反例和一些别的事情的讨论(当然,有些反例可能属于钻牛角尖,可能有点学院派,不过也不排除其实际可能性,就算是提个醒吧):


    其一、Class Loader。不知道你对Java的Class Loader熟悉吗?“类装载器”?!C++可没有这个东西啊。这是Java动态性的核心。顾名思义,类装载器是用来把类(class)装载进JVM的。JVM规范定义了两种类型的类装载器:启动内装载器(bootstrap)和用户自定义装载器(user-defined class loader)。 在一个JVM中可能存在多个ClassLoader,每个ClassLoader拥有自己的NameSpace。一个ClassLoader只能拥有一个class对象类型的实例,但是不同的ClassLoader可能拥有相同的class对象实例,这时可能产生致命的问题。如ClassLoaderA,装载了类A的类型实例A1,而ClassLoaderB,也装载了类A的对象实例A2。逻辑上讲A1=A2,但是由于A1和A2来自于不同的ClassLoader,它们实际上是完全不同的,如果A中定义了一个静态变量c,则c在不同的ClassLoader中的值是不同的。


    于是,如果咱们的Singleton 1.3版本如果面对着多个Class Loader会怎么样?呵呵,多个实例同样会被多个Class Loader创建出来,当然,这个有点牵强,不过他确实存在。难道我们还要整出个1.4版吗?可是,我们怎么可能在我的Singleton类中操作Class Loader啊?是的,你根本不可能。在这种情况下,你能做的只有是——“保证多个Class Loader不会装载同一个Singleton”。


    其二、序例化。如果我们的这个Singleton类是一个关于我们程序配置信息的类。我们需要它有序列化的功能,那么,当反序列化的时候,我们将无法控制别人不多次反序列化。不过,我们可以利用一下Serializable接口的readResolve()方法,比如:


    其三、多个Java虚拟机。如果我们的程序运行在多个Java的虚拟机中。什么?多个虚拟机?这是一种什么样的情况啊。嗯,这种情况是有点极端,不过还是可能出现,比如EJB或RMI之流的东西。要在这种环境下避免多实例,看来只能通过良好的设计或非技术来解决了。


    其四,volatile变量。关于volatile这个关键字所声明的变量可以被看作是一种 “程度较轻的同步synchronized”;与 synchronized 块相比,volatile 变量所需的编码较少,并且运行时开销也较少,但是它所能实现的功能也仅是synchronized的一部分。当然,如前面所述,我们需要的Singleton只是在创建的时候线程同步,而后面的读取则不需要同步。所以,volatile变量并不能帮助我们即能解决问题,又有好的性能。而且,这种变量只能在JDK 1.5+版后才能使用。


    其五、关于继承。是的,继承于Singleton后的子类也有可能造成多实例的问题。不过,因为我们早把Singleton的构造函数声明成了私有的,所以也就杜绝了继承这种事情。


    其六,关于代码重用。也话我们的系统中有很多个类需要用到这个模式,如果我们在每一个类都中有这样的代码,那么就显得有点傻了。那么,我们是否可以使用一种方法,把这具模式抽象出去?在C++下这是很容易的,因为有模板和友元,还支持栈上分配内存,所以比较容易一些(程序如下所示),Java下可能比较复杂一些,聪明的你知道怎么做吗?


    (转载时请注明作者和出处。未经许可,请勿用于商业用途)


    展开全文
  • 单实例Singleton设计模式可能是被讨论和使用的最广泛的一个设计模式了,这可能也是面试中问得最多的一个设计模式了。这个设计模式主要目的是想在整个系统中只能出现一个类的实例。这样做当然是有必然的,比如你的...
  • Singleton设计模式

    2009-04-14 10:21:00
    Singleton的1.0版本public class Singleton{private static final Singleton singleton = null;private Singleton(){}public static Singleton getInstance(){if (singleton== null){singleton= new Singleton();}r
  • 设计模式C++学习之单例模式(Singleton
  • C++设计模式 - 单例模式(Singleton

    千次阅读 2022-03-10 22:02:47
    单例模式其意图是:保证一个类只有一个实例,并提供一个访问它的全局访问点。 为了防止外部类构造实例,需要将构造函数的访问权限标记为protected或private; 需要提供全局访问点,就需要在类中定义一个static函数...
  • 单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个...
  • 设计模式-Singleton模式

    千次阅读 2019-05-27 15:33:15
    Singleton模式是什么? Singleton字面意思,单例,那也就是说无论如何这个类只有一个实例对象,你没有办法new出多个这个类的实例。 应用场景 想确保任何情况下都绝对只有1个实例 想在程序上表现出“只存在一个实例...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 116,415
精华内容 46,566
关键字:

singleton设计模式

友情链接: my-DPCM.rar