精华内容
下载资源
问答
  • 单例设计模式

    2019-10-12 20:54:14
    单例设计模式单例设计模式 单例设计模式 作用:在应用程序中有保证最多只能有一个实例 好处: 提升运行效率 实现数据共享比如:application对象,其在四大作用域共享 懒汉式 单例设计模式: 第一步:构造...

    单例设计模式

    单例设计模式

    1. 作用:在应用程序中有保证最多只能有一个实例
    2. 好处:
      提升运行效率
      实现数据共享比如:application对象,其在四大作用域共享
    3. 懒汉式
      为什么叫懒汉式:因为对象只有被调用的时候才会被创建
      单例设计模式:
      第一步:构造方法私有化,那么其他类就不可以实例化这个对象,
    public class SingleTon {
        //由于对象需要被静态方法调用,所以对象设置为static
        //由于对象是static,必须把设置访问权限修饰符改为private,如果是public的话,不经过访问入口
        private static SingleTon singleTon;
        private SingleTon(){} //设置成私有化的时候需要对外提供一个访问入口
        //实例方法必须通过对象调用,此时不可以,所以将方法设置为静态方法
        public static SingleTon getInstance(){
            //添加逻辑 如果实例化过,直接返回
            if (singleTon == null){
                /**
                 * 多线程访问下,可能出现if同时成立的情况,添加锁
                 */
                synchronized (SingleTon.class){
                    if (singleTon == null){
                        singleTon = new SingleTon();
                    }
                }
            }
            return singleTon;
        }
    }
    
    

    由于添加了锁,所以导致了效率的降低
    4. 饿汗式
    解决了多线程访问可能出现同一个对象和效率低的问题

    public class NewSingleTon {
        //为了避免锁的冲突以及效率问题,在类加载的时候进行实例化
        private static NewSingleTon newSingleTon = new NewSingleTon();
        private NewSingleTon(){}
        public static NewSingleTon getInstance(){
            return newSingleTon;
        }
    }
    
    
    1. 测试类
    public class Test {
        public static void main(String[] args) {
            SingleTon singleTon = SingleTon.getInstance();
            SingleTon singleTon1 = SingleTon.getInstance();
            System.out.println(singleTon == singleTon1);
    
        }
    }
    
    展开全文
  • 设计模式之单例设计模式

    万次阅读 多人点赞 2021-03-21 20:28:27
    JAVA一共有23种设计模式,我们今天首先来学其中一种:单例设计模式 2 单例设计模式 单例模式可以说是大多数开发人员在实际中使用最多的,常见的Spring默认创建的bean就是单例模式的。 单例模式有很多好处,比如可节约...

    1 设计模式(Design pattern)

    代表了最佳的实践,通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。
    JAVA一共有23种设计模式,我们今天首先来学其中一种:单例设计模式
    23种设计模式

    2 单例设计模式

    单例模式可以说是大多数开发人员在实际中使用最多的,常见的Spring默认创建的bean就是单例模式的。
    单例模式有很多好处,比如可节约系统内存空间,控制资源的使用。
    其中单例模式最重要的是确保对象只有一个。
    简单来说,保证一个类在内存中的对象就一个。
    RunTime就是典型的单例设计,我们通过对RunTime类的分析,一窥究竟。

    3 RunTime单例设计源码剖析

     /**
     * Every Java application has a single instance of class
     * <code>Runtime</code> that allows the application to interface with
     * the environment in which the application is running. The current
     * runtime can be obtained from the <code>getRuntime</code> method.
     * <p>
     * An application cannot create its own instance of this class.
     *
     * @author  unascribed
     * @see     java.lang.Runtime#getRuntime()
     * @since   JDK1.0
     */
    public class Runtime {
    	//1.创建静态的全局唯一的对象
    private static Runtime currentRuntime = new Runtime();
    
    //2.私有化构造方法,不让外部来调用
        /** Don't let anyone else instantiate this class */
        private Runtime() {}
        
    	//3.通过自定义的静态方法获取实例
        public static Runtime getRuntime() {
            return currentRuntime;
    }
    }
    

    通过分析,底层的实现思路一共分为了3个步骤:

    • 对本类构造方法私有化,防止外部调用构造方法创建对象
    • 创建全局唯一的对象,也做私有化处理
    • 通过自定义的公共方法将创建好的对象返回(类似封装属性后的getXxx() )

    那我们不妨自己尝试着来写写单例模式

    4 练习:单例设计模式1-饿汉式实现方式

    创建包: cn.tedu.design
    创建类: Singleton1.java

    package cn.tedu.design;
    /*本类用于测试单例设计模式 1 - 饿汉式*/
    public class Singleton1 {
        public static void main(String[] args) {
            //6.通过类名调用getSingle()方法获取本类对象
            MySingle single1 = MySingle.getSingle();
            MySingle single2 = MySingle.getSingle();
    
            //7.测试获取到的这两个引用类型变量是否相等
            System.out.println(single1 == single2);//true,==比较的是地址值,说明是同一个对象
            System.out.println(single1);//cn.tedu.single.MySingle@1b6d3586
            System.out.println(single2);//cn.tedu.single.MySingle@1b6d3586
        }
    }
    //0.创建自己的单例程序
    class MySingle{
        //1.提供构造方法,并将构造方法私有化
        /*1.构造方法私有化的目的:为了不让外界随意实例化/new本类对象*/
        private MySingle(){ };
    
        /*3.思考:构造方法和对象私有化后,通过公共的访问点来获取对象,那外界如何调用这个公共方法呢?
        * 之前我们都是在外部创建本类对象并进行方法调用,但是现在单例程序中外部无法直接创建本类对象
        * 解决方案:我们可以利用之前学习的静态的概念,将方法修饰成静态的,就可以通过类名直接调用啦
        * 注意事项:静态只能调用静态,所以静态方法中返回的对象也需用静态修饰*/
        //2.在类的内部,创建本类对象,并且私有化
        //5.2本资源也需要使用static修饰,因为静态方法getSingle()只能调用静态资源
        static private MySingle single = new MySingle();
    
        /*2.也就是以公共的方式向外界提供获取本类私有对象的方法*/
        //3.对外提供一个公共的全局访问点
        //5.1用static关键字来修饰本方法,为了外部可以通过类名直接调用本方法
        static public MySingle getSingle(){
            //4.把内部创建好的对象返回到调用位置,谁调用这个方法,谁就能拿到返回的single对象
            return single;
        }
    }
    

    2.4 单例设计模式2-懒汉式实现方式
    创建包: cn.tedu.design
    创建类: Singleton2.java

    package cn.tedu.single;
    /*本类用于测试单例设计模式 2 - 懒汉式--面试重点!!!*/
    /*总结:
    * 关于单例设计模式的两种实现方式:
    * 1.饿汉式 : 不管你用不用这个类的对象,都会直接先创建一个
    * 2.懒汉式 : 先不给你创建这个类的对象,等你需要的时候再帮你创建--利用了延迟加载的思想
    * 延迟加载的思想:是指不会在第一时间就把对象创建好来占用内存,而是什么时候用到,什么时候再去创建对象
    * 3.线程安全问题 : 是指共享资源有线程并发的数据安全隐患,可以通过加锁的方式[同步代码块/同步方法]
    * */
    public class Singleton2 {
        public static void main(String[] args) {
            //6.创建对象进行测试
            MySingle2 s1 = MySingle2.getMySingle2();
            MySingle2 s2 = MySingle2.getMySingle2();
            System.out.println( s1 == s2 );//true,比较的是地址值,说明是同一个对象
            System.out.println( s1 );//cn.tedu.single.MySingle2@1b6d3586
            System.out.println( s2 );//cn.tedu.single.MySingle2@1b6d3586
        }
    }
    //0.创建单例程序
    class MySingle2{
        //1.私有化构造方法,为了防止外部调用构造方法直接创建本类对象
        private MySingle2(){}
        //2.在类的内部创建好引用类型变量(延迟加载的思想)--注意私有化
        //5.2本处的引用类型变量也需要修饰成static的,因为静态只能调用静态,getMySingle2()是静态方法
        static private MySingle2 single2;
        //7.2.2同步代码块中使用的唯一的锁对象
        static Object o = new Object();
        /*问题:程序中有共享资源single2,并且有多条语句(3句)操作了共享资源
        * 此时single2共享资源在多线程环境下一定会存在多线程数据安全隐患
        * 解决方案1:同步代码块[加锁,范围是操作共享资源的所有代码]
        * 解决方案2:同步方法[如果方法中的所有代码都需要被同步,那么这个方法可以修饰成同步方法]
        * 注意事项:锁对象在静态方法中,不可以使用this,因为静态资源优先于对象加载
        * 锁对象可以使用外部创建好的唯一的锁对象o,但请注意,需要是静态的,静态只能调用静态
        * */
        //3.对外提供公共的全局访问点
        //5.1注意要使用static来修饰本公共方法,为了方便后续可以通过类名直接调用
        //7.1将方法修饰成同步方法
        synchronized static public MySingle2 getMySingle2(){
            //4.当用户调用此方法时,才说明用到这个对象了,那么我们就把这个对象返回
            /*注意:这里需要增加一个判断
            如果调用方法时single2的值为null,说明之前没有new过,保存的是默认值
            这时才需要new对象,如果single2的值不为null,直接return single2即可*/
            //7.2可以将操作共享资源的多条语句放入同步代码块之中
            synchronized (o) {
            //synchronized (this) {
                if (single2 == null) {
                    single2 = new MySingle2();//没有对象时才创建对象,并赋值给single2
                }
                return single2;//有对象则直接返回single2
            }
        }
    }
    

    单例设计模式到这里就结束啦,后续我们还可以继续学习下其他的设计模式哦~

    下一节 注解 点这里哦

    展开全文
  • class Singleton { //构造器私有化 private Singleton() {} //写一个静态内部类,该类中有一个静态属性 Singleton private static class SingletonInstance { private static final Singleton INSTANCE = ...
  • 在实际的编程开发中,单例设计模式是我们谈得最多但用得最少的设计模式。单例设计模式的4种实现方式: 饿汉式、懒汉式、静态内部类式、枚举式,我这里就不说了。详情请参考我的另一篇博客 java使用枚举、饿汉式、...

    在实际的编程开发中,单例设计模式是我们谈得最多但用得最少的设计模式。单例设计模式的4种实现方式:

    饿汉式、懒汉式、静态内部类式、枚举式,我这里就不说了。详情请参考我的另一篇博客

    java使用枚举、饿汉式、懒汉式、内部类实现单例设计模式

    可以说我到现在都没有使用上(在实际公司工作中),为什么会这样呢,我们来看看单例设计模式有哪些常见的应用场景

    1. window 的控制面板、任务管理器、回收站
    2. 网站的计数器
    3. 应用程序的日志应用:log4j、slf4j、logkback
    4. 项目中配置文件的读取
    5. 线程池(管理多个线程):java 自带线程池
    6. 数据库连接池(管理多个数据库连接):c3po 等
    7. 文件系统

    从以上使用场景我们可以看出 ,其实那些所谓的常用场景,只要写一次,后期就基本上不会去改动了。所以我们用得非常少,但为什么我们总是谈起单例模式呢,就是那些面试官总是问这些问题,真不明白为什么老是要问这些,面试时造飞机大炮,工作时写HTML,不知道各位有没有同感。

    在Java中,运行时类也就是Runtime类,被设计成是单例的饿汉式,spring 中的bean 和spring mvc 中的controller、service、dao层中通过@autowire的依赖注入对象默认都是单例的,使用单例的目的当然是节约内存节省资源。

    其实我也就发发牢骚,不知道各位有什么看法,欢迎下方评论!

    展开全文
  • C++单例设计模式,单例模式 C++单例设计模式,单例模式
  • [设计模式]单例设计模式

    千次阅读 2020-04-14 20:39:47
    单例设计模式 单例设计模式是指某个类只能生成一个实例(对象),该类提供了一个全局访问点供外部获取该实例. 可以拓展为有限多例模式 代码展示 ...

    github地址:https://github.com/1711680493

    点我进入github

    如需了解更多设计模式,请进入我的设计模式专栏

    单例设计模式

    单例设计模式是指某个类只能生成一个实例(对象),该类提供了一个全局访问点供外部获取该实例.

    可以拓展为有限多例模式 

    单例模式展示

    /**
     * 单例设计模式
     * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>
     * @version 1.0
     */
    public class SingleMode {
    	/**
    	 * 此类唯一的对象
    	 */
    	private static SingleMode single = new SingleMode();
    	/**
    	 * 构造私有 别的类无法创建此类对象
    	 */
    	private SingleMode() {}
    	
    	/**
    	 * 将唯一的对象通过某种方法提供出去 供外界使用
    	 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>
    	 * @return
    	 */
    	public static SingleMode getSingle() {
    		return single;
    	}
    }

    实例展示

    在Windows操作系统中,系统自带的东西大部分都是单例模式的,比如回收站,任务管理器,资源管理器等.

    例子:创建一个ShendiPerson类,拥有Money的属性,使用单例模式来获取/更改参数

    /**
     * 单例模式测试类
     * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>
     * @version 1.0
     */
    public class SingleModeTest {
    	public static void main(String[] args) {
    		//获取唯一的对象
    		ShendiPerson shendi1 = ShendiPerson.getShendi();
    		//在获取一次 验证效果
    		ShendiPerson shendi2 = ShendiPerson.getShendi();
    		//现在的money是为0的 初始值 我们设置shendi1的money
    		shendi1.setMoney(666666666);
    		//输出看一下结果
    		System.out.println("shendi1 设置了money: " + shendi1.getMoeny());
    		//shendi2我们是没有设置money的 获取看一下数值
    		System.out.println("shendi2 没有设置money: " + shendi2.getMoeny());
    	}
    }
    
    class ShendiPerson {
    	/**
    	 * 创建此类唯一的对象
    	 */
    	private static final ShendiPerson SHENDI = new ShendiPerson();
    	private ShendiPerson() {};
    	
    	/**
    	 * 钱
    	 */
    	private int money;
    	
    	/**
    	 * 设置钱的方法
    	 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>
    	 * @param money
    	 */
    	public void setMoney(int money) { this.money = money; }
    	/**
    	 * 钱是私有的,提供的获取钱的方法
    	 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>
    	 * @return
    	 */
    	public int getMoeny() { return money; }
    	
    	/**
    	 * 返回唯一对象的方法
    	 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>
    	 * @return
    	 */
    	public static ShendiPerson getShendi() {
    		return SHENDI;
    	}
    }

    结果:

    展开全文
  • Java 单例设计模式

    2020-10-28 11:49:45
    Java单例设计模式 一、什么是单例设计模式 单例设计模式,就是采取一定的方法保证在整个软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法。 二、如何应用单例设计模式 根据...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 190,225
精华内容 76,090
关键字:

单例设计模式