精华内容
下载资源
问答
  • java中用单例模式有什么好处

    千次阅读 2019-03-04 13:40:00
    java中用单例模式有什么好处 ava Singleton模式主要作用是保证在Java应用程序中,一个类Class只有一个实例存在。 使用Singleton的好处还在于可以节省内存,因为它限制了实例的个数,有利于Java垃圾回收(garbage ...

    java中用单例模式有什么好处

    ava Singleton模式主要作用是保证在Java应用程序中,一个类Class只有一个实例存在。 使用Singleton的好处还在于可以节省内存,因为它限制了实例的个数,有利于Java垃圾回收(garbage collection)。

    使用单例模式最核心的一点是体现了面向对象封装特性中的“单一职责”和“对象自治”原则。

    很多时候我们要保证类的实例只有一个。我们可能在自己的代码中判断需要的类的实例有无,无就new一个。这样看似不错。问题是,你用到这个类的地方有n个,这样你就需要n个判断。为什么不把这个职责交给类本身呢?然后让类提供一个接口访问。
    在浏览BBS、SNS网站的时候,常常会看到“当前在线人数”这样的一项内容。对于这样的一项功能,我们通常的做法是把当前的在线人数存放到一个内存、文件或者数据库中,每次用户登录的时候,就会马上从内存、文件或者数据库中取出,在其基础上加1后,作为当前的在线人数进行显示,然后再把它保存回内存、文件或者数据库里,这样后续登录的用户看到的就是更新后的当前在线人数;同样的道理,当用户退出后,当前在线人数进行减1的工作。所以,对于这样的一个需求,我们按照面向对象的设计思想,可以把它抽象为“在线计数器”这样一个对象。

    网站代码中凡是用到计数器的地方,只要new一个计数器对象,然后就可以获取、保存、增加或者减少在线人数的数量。不过,我们的代码实际的使用效果并不好。假如有多个用户同时登录,那么在这个时刻,通过计数器取到的在线人数是相同的,于是他们使用各自的计数器加1后存入文件或者数据库。这样操作后续登陆的用户得到的在线人数,与实际的在线人数并不一致。所以,把这个计数器设计为一个全局对象,所有人都共用同一份数据,就可以避免类似的问题,这就是我们所说的单例模式的其中的一种应用。

    单例模式能够保证一个类仅有唯一的实例,并提供一个全局访问点。
    我们是不是可以通过一个全局变量来实现单例模式的要求呢?我们只要仔细地想想看,全局变量确实可以提供一个全局访问点,但是它不能防止别人实例化多个对象。通过外部程序来控制的对象的产生的个数,势必会系统的增加管理成本,增大模块之间的耦合度。所以,最好的解决办法就是让类自己负责保存它的唯一实例,并且让这个类保证不会产生第二个实例,同时提供一个让外部对象访问该实例的方法。自己的事情自己办,而不是由别人代办,这非常符合面向对象的封装原则。

    单例模式主要有3个特点,:
    1、单例类确保自己只有一个实例。
    2、单例类必须自己创建自己的实例。
    3、单例类必须为其他对象提供唯一的实例。

    单例模式的实现方式:懒汉单例类和饿汉单例类
    单例模式的实现有多种方法,常见的就有懒汉式单例类和饿汉式单例类。我们前面介绍的实现方法就属于懒汉式单例类。

    懒汉式单例类
    对于懒汉模式,我们可以这样理解:该单例类非常懒,只有在自身需要的时候才会行动,从来不知道及早做好准备。它在需要对象的时候,才判断是否已有对象,如果没有就立即创建一个对象,然后返回,如果已有对象就不再创建,立即返回。
    懒汉模式只在外部对象第一次请求实例的时候才去创建。

    饿汉式单例
    对于饿汉模式,我们可以这样理解:该单例类非常饿,迫切需要吃东西,所以它在类加载的时候就立即创建对象。

    我们对比一下懒汉模式和饿汉模式的优缺点:
    懒汉模式,它的特点是运行时获得对象的速度比较慢,但加载类的时候比较快。它在整个应用的生命周期只有一部分时间在占用资源。
    饿汉模式,它的特点是加载类的时候比较慢,但运行时获得对象的速度比较快。它从加载到应用结束会一直占用资源。
    这两种模式对于初始化较快,占用资源少的轻量级对象来说,没有多大的性能差异,选择懒汉式还是饿汉式都没有问题。但是对于初始化慢,占用资源多的重量级对象来说,就会有比较明显的差别了。所以,对重量级对象应用饿汉模式,类加载时速度慢,但运行时速度快;懒汉模式则与之相反,类加载时速度快,但运行时第一次获得对象的速度慢。
    从用户体验的角度来说,我们应该首选饿汉模式。我们愿意等待某个程序花较长的时间初始化,却不喜欢在程序运行时等待太久,给人一种反应迟钝的感觉,所以对于有重量级对象参与的单例模式,我们推荐使用饿汉模式。
    而对于初始化较快的轻量级对象来说,选用哪种方法都可以。如果一个应用中使用了大量单例模式,我们就应该权衡两种方法了。轻量级对象的单例采用懒汉模式,减轻加载时的负担,缩短加载时间,提高加载效率;同时由于是轻量级对象,把这些对象的创建放在使用时进行,实际就是把创建单例对象所消耗的时间分摊到整个应用中去了,对于整个应用的运行效率没有太大影响。

    什么情况下使用单例模式
    单例模式也是一种比较常见的设计模式,它到底能带给我们什么好处呢?其实无非是三个方面的作用:
    第一、控制资源的使用,通过线程同步来控制资源的并发访问;
    第二、控制实例产生的数量,达到节约资源的目的。
    第三、作为通信媒介使用,也就是数据共享,它可以在不建立直接关联的条件下,让多个不相关的两个线程或者进程之间实现通信。
    比如,数据库连接池的设计一般采用单例模式,数据库连接是一种数据库资源。软件系统中使用数据库连接池,主要是节省打开或者关闭数据库连接所引起的效率损耗,这种效率上的损耗还是非常昂贵的。当然,使用数据库连接池还有很多其它的好处,可以屏蔽不同数据数据库之间的差异,实现系统对数据库的低度耦合,也可以被多个系统同时使用,具有高可复用性,还能方便对数据库连接的管理等等。数据库连接池属于重量级资源,一个应用中只需要保留一份即可,既节省了资源又方便管理。所以数据库连接池采用单例模式进行设计会是一个非常好的选择。
    在我们日常使用的在Windows中也有不少单例模式设计的组件,象常用的文件管理器。由于Windows操作系统是一个典型的多进程多线程系统,那么在创建或者删除某个文件的时候,就不可避免地出现多个进程或线程同时操作一个文件的现象。采用单例模式设计的文件管理器就可以完美的解决这个问题,所有的文件操作都必须通过唯一的实例进行,这样就不会产生混乱的现象。
    再比如,每台计算机可以有若干个打印机,如果每一个进程或者线程都独立地使用打印机资源的话,那么我们打印出来的结果就有可能既包含这个打印任务的一部分,又包含另外一个打印任务的一部分。所以,大多数的操作系统最终为打印任务设计了一个单例模式的假脱机服务Printer Spooler,所有的打印任务都需要通过假脱机服务进行。
    实际上,配置信息类、管理类、控制类、门面类、代理类通常被设计为单例类。像Java的Struts、Spring框架,.Net的Spring.Net框架,以及Php的Zend框架都大量使用了单例模式。

    以上转至:https://www.jobui.com/mianshiti/it/java/7019/

    //单例模式-饿汉式
    public class Singleton {
    
        public static Singleton singleton = new Singleton();
        
        private Singleton() {
        }
        
        public static Singleton getInstance() {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return singleton;
        }
        
    }
    
    //单例模式-懒汉式
    public class Singleton2 {
    
        public static Singleton2 singleton2;
        
        private Singleton2() {
        }
        
        public static Singleton2 getInstance() {
            if (singleton2 == null) {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                singleton2 = new Singleton2();
            }
            return singleton2;
        }
    }
    
    //饿汉式单例模式测试代码
    public class SingletonTest {
    
        public static void main(String[] args) {
            for (int i = 0; i < 10; i++) {
                new MyThread().start();
            }
        }
    }
    
    class MyThread extends Thread {
        @Override
        public void run() {
            Singleton instance = Singleton.getInstance();
            System.out.println(instance);
        }
    }
    
    
    //懒汉式单例模式测试代码
    public class SingletonTest2 {
    
        public static void main(String[] args) {
            for (int i = 0; i < 10; i++) {
                new MyThread2().start();
            }
        }
    }
    
    class MyThread2 extends Thread {
        @Override
        public void run() {
            Singleton2 instance = Singleton2.getInstance();
            System.out.println(instance);
        }
    }
    

    总结:上述两种单例模式在单线程的情况下都符合单例的要求,但是懒汉式单例模式在多线程的情况下会出现多例的情况,不符合单例模式的要求,而饿汉式单例模式在多线程的情况下仍只会产生一个实例,符合单例模式的要求。故如果在多线程环境下想要使用单例模式那么应用饿汉式单例模式

    展开全文
  • class Config1 {} ... 为什么初始值null,因为类内部访问接口需要检测实例的状态,判断是否需要实例化 private static $instance = null; //保存用户的自定义配置参数 private $setting = []; //构造
    class Config1 {}
    class Config
    {
    * 必须先声明一个静态私有属性:用来保存当前类的实例
    * 1. 为什么必须是静态的?因为静态成员属于类,并被类所有实例所共享
    * 2. 为什么必须是私有的?不允许外部直接访问,仅允许通过类方法控制方法
    * 3. 为什么要有初始值null,因为类内部访问接口需要检测实例的状态,判断是否需要实例化
    
    private static $instance = null;
    //保存用户的自定义配置参数
    private $setting = [];
    //构造器私有化:禁止从类外部实例化
    private function __construct(){}
    //克隆方法私有化:禁止从外部克隆对象
    private function __clone(){}
            //因为用静态属性返回类实例,而只能在静态方法使用静态属性
            //所以必须创建一个静态方法来生成当前类的唯一实例
    public static function getInstance()
    {
                //检测当前类属性$instance是否已经保存了当前类的实例
                if (self::$instance == null) {
                    //如果没有,则创建当前类的实例
                    self::$instance = new self();
                }
                //如果已经有了当前类实例,就直接返回,不要重复创建类实例
                return self::$instance;
    }
    //设置配置项
    public function set($index, $value)
    {
    $this->setting[$index] = $value;
    }
    //读取配置项
    public function get($index)
    {
    return $this->setting[$index];
    }
    }
    $obj1 = new Config1;
    $obj2 = new Config1;
    var_dump($obj1,$obj2);
    echo '<hr>';
    //实例化Config类
    $obj1 = Config::getInstance();
    $obj2 = Config::getInstance();
    var_dump($obj1,$obj2);
    $obj1->set('host','localhost');
    echo $obj1->get('host');
    
    • 单例模式:一个类仅允许创建一个实例

    一、什么是单例模式
    作为对象的创建模式,单例模式确保某一个类只有一个实例,并且对外提供这个全局实例的访问入口。它不会创建实例副本,而是会向单例类内部存储的实例返回一个引用。

    二、PHP单例模式三要素

    1. 需要一个保存类的唯一实例的静态成员变量。
    2. 构造函数和克隆函数必须声明为私有的,防止外部程序创建或复制实例副本。
    3. 必须提供一个访问这个实例的公共静态方法,从而返回唯一实例的一个引用。

    三、为什么使用单例模式
    使用单例模式的好处很大,以数据库操作为例。若不采用单例模式,当程序中出现大量数据库操作时,每次都要执行new操作,
    每次都会消耗大量的内存资源和系统资源,而且每次打开和关闭数据库连接都是对数据库的一种极大考验和浪费。使用了单例模式,只需要实例化一次,不需要每次都执行new操作,极大降低了资源的耗费。

    四、单例模式示例
    这里以数据库操作为例

    <?php
    /**
    *  单例模式
    **/
    class Db
    {
      //保存全局实例
      private static $instance;
      //数据库连接句柄
      private $db;
      //数据库连接参数
      const HOSTNAME = "127.0.0.1";
      const USERNAME = "root";
      const PASSWORD = "root";
      const DBNAME = "testdb";
      //私有化构造函数,防止外界实例化对象
      private function __construct()
      {
        $this->db = mysqli_connect(self::HOSTNAME,self::USERNAME,
          self::PASSWORD,self::DBNAME);
      }
      //私有化克隆函数,防止外界克隆对象
      private function __clone()
      {
      }
      //单例访问统一入口
      public static function getInstance()
      {
        if(!(self::$instance instanceof self))
        {
          self::$instance = new self();
        }
        return self::$instance;
      }
      //数据库查询操作
      public function getinfo()
      {
        $sql = "select * from testtb";
        $res = mysqli_query($this->db,$sql);
        while($row = mysqli_fetch_array($res)) {
          echo $row['testcol'] . '<br />';
        }
        mysqli_free_result($res);
      }
    }
    $mysqli = Db::getInstance();
    $mysqli->getinfo();
    ?>
    
    展开全文
  • Java中用单例模式有什么好处

    万次阅读 2017-05-12 10:05:02
    Java Singleton模式主要作用是保证在Java应用程序中,一个类Class只有一个实例存在。 使用Singleton的好处还在于可以节省内存,因为它限制了实例的个数,有利于Java垃圾回收(garbage collection)。我们在浏览BBS、...

    Java Singleton模式主要作用是保证在Java应用程序中,一个类Class只有一个实例存在。 使用Singleton的好处还在于可以节省内存,因为它限制了实例的个数,有利于Java垃圾回收(garbage collection)。

    我们在浏览BBS、SNS网站的时候,常常会看到“当前在线人数”这样的一项内容。对于这样的一项功能,我们通常的做法是把当前的在线人数存放到一个内存、文件或者数据库中,每次用户登录的时候,就会马上从内存、文件或者数据库中取出,在其基础上加1后,作为当前的在线人数进行显示,然后再把它保存回内存、文件或者数据库里,这样后续登录的用户看到的就是更新后的当前在线人数;同样的道理,当用户退出后,当前在线人数进行减1的工作。所以,对于这样的一个需求,我们按照面向对象的设计思想,可以把它抽象为“在线计数器”这样一个对象。

    网站代码中凡是用到计数器的地方,只要new一个计数器对象,然后就可以获取、保存、增加或者减少在线人数的数量。不过,我们的代码实际的使用效果并不好。假如有多个用户同时登录,那么在这个时刻,通过计数器取到的在线人数是相同的,于是他们使用各自的计数器加1后存入文件或者数据库。这样操作后续登陆的用户得到的在线人数,与实际的在线人数并不一致。所以,把这个计数器设计为一个全局对象,所有人都共用同一份数据,就可以避免类似的问题,这就是我们所说的单例模式的其中的一种应用。

    单例模式能够保证一个类仅有唯一的实例,并提供一个全局访问点。

    我们是不是可以通过一个全局变量来实现单例模式的要求呢?我们只要仔细地想想看,全局变量确实可以提供一个全局访问点,但是它不能防止别人实例化多个对象。通过外部程序来控制的对象的产生的个数,势必会系统的增加管理成本,增大模块之间的耦合度。所以,最好的解决办法就是让类自己负责保存它的唯一实例,并且让这个类保证不会产生第二个实例,同时提供一个让外部对象访问该实例的方法。自己的事情自己办,而不是由别人代办,这非常符合面向对象的封装原则。

    单例模式主要有3个特点,:

    1、单例类确保自己只有一个实例。

    2、单例类必须自己创建自己的实例。

    3、单例类必须为其他对象提供唯一的实例。

    单例模式的实现方式:懒汉单例类和饿汉单例类

    单例模式的实现有多种方法,常见的就有懒汉式单例类和饿汉式单例类。我们前面介绍的实现方法就属于懒汉式单例类。

    · 懒汉式单例类

    对于懒汉模式,我们可以这样理解:该单例类非常懒,只有在自身需要的时候才会行动,从来不知道及早做好准备。它在需要对象的时候,才判断是否已有对象,如果没有就立即创建一个对象,然后返回,如果已有对象就不再创建,立即返回。

    懒汉模式只在外部对象第一次请求实例的时候才去创建。

    · 饿汉式单例

    对于饿汉模式,我们可以这样理解:该单例类非常饿,迫切需要吃东西,所以它在类加载的时候就立即创建对象。

    我们对比一下懒汉模式和饿汉模式的优缺点:

    懒汉模式,它的特点是运行时获得对象的速度比较慢,但加载类的时候比较快。它在整个应用的生命周期只有一部分时间在占用资源。

    饿汉模式,它的特点是加载类的时候比较慢,但运行时获得对象的速度比较快。它从加载到应用结束会一直占用资源。

    这两种模式对于初始化较快,占用资源少的轻量级对象来说,没有多大的性能差异,选择懒汉式还是饿汉式都没有问题。但是对于初始化慢,占用资源多的重量级对象来说,就会有比较明显的差别了。所以,对重量级对象应用饿汉模式,类加载时速度慢,但运行时速度快;懒汉模式则与之相反,类加载时速度快,但运行时第一次获得对象的速度慢。

    从用户体验的角度来说,我们应该首选饿汉模式。我们愿意等待某个程序花较长的时间初始化,却不喜欢在程序运行时等待太久,给人一种反应迟钝的感觉,所以对于有重量级对象参与的单例模式,我们推荐使用饿汉模式。

    而对于初始化较快的轻量级对象来说,选用哪种方法都可以。如果一个应用中使用了大量单例模式,我们就应该权衡两种方法了。轻量级对象的单例采用懒汉模式,减轻加载时的负担,缩短加载时间,提高加载效率;同时由于是轻量级对象,把这些对象的创建放在使用时进行,实际就是把创建单例对象所消耗的时间分摊到整个应用中去了,对于整个应用的运行效率没有太大影响。

    什么情况下使用单例模式

    单例模式也是一种比较常见的设计模式,它到底能带给我们什么好处呢?其实无非是三个方面的作用:

    第一、控制资源的使用,通过线程同步来控制资源的并发访问;

    第二、控制实例产生的数量,达到节约资源的目的。

    第三、作为通信媒介使用,也就是数据共享,它可以在不建立直接关联的条件下,让多个不相关的两个线程或者进程之间实现通信。

    比如,数据库连接池的设计一般采用单例模式,数据库连接是一种数据库资源。软件系统中使用数据库连接池,主要是节省打开或者关闭数据库连接所引起的效率损耗,这种效率上的损耗还是非常昂贵的。当然,使用数据库连接池还有很多其它的好处,可以屏蔽不同数据数据库之间的差异,实现系统对数据库的低度耦合,也可以被多个系统同时使用,具有高可复用性,还能方便对数据库连接的管理等等。数据库连接池属于重量级资源,一个应用中只需要保留一份即可,既节省了资源又方便管理。所以数据库连接池采用单例模式进行设计会是一个非常好的选择。

    在我们日常使用的在Windows中也有不少单例模式设计的组件,象常用的文件管理器。由于Windows操作系统是一个典型的多进程多线程系统,那么在创建或者删除某个文件的时候,就不可避免地出现多个进程或线程同时操作一个文件的现象。采用单例模式设计的文件管理器就可以完美的解决这个问题,所有的文件操作都必须通过唯一的实例进行,这样就不会产生混乱的现象。

    再比如,每台计算机可以有若干个打印机,如果每一个进程或者线程都独立地使用打印机资源的话,那么我们打印出来的结果就有可能既包含这个打印任务的一部分,又包含另外一个打印任务的一部分。所以,大多数的操作系统最终为打印任务设计了一个单例模式的假脱机服务Printer Spooler,所有的打印任务都需要通过假脱机服务进行。

    实际上,配置信息类、管理类、控制类、门面类、代理类通常被设计为单例类。像Java的Struts、spring框架,.Net的Spring.NET框架,以及PHP的Zend框架都大量使用了单例模式。

    详细内容请参考:

    使用单例模式最核心的一点是体现了面向对象封装特性中的“单一职责”和“对象自治”原则。

    很多时候我们要保证类的实例只有一个。我们可能在自己的代码中判断需要的类的实例有无,无就new一个。这样看似不错。问题是,你用到这个类的地方有n个,这样你就需要n个判断。为什么不把这个职责交给类本身呢?然后让类提供一个接口访问
    以上引自:http://blog.csdn.net/ljhljh8888/article/details/8017701
    最后附上两种单例模式的java代码:

    懒汉式:
    public class SingletonClass{
        private static SingletonClass instance=null;
        public static synchronized SingletonClass getInstance(){
            if(instance==null){
                   instance=new SingletonClass();
            }
            return instance;
        }
        private SingletonClass(){
        }
    }
    饿汉式:
    public class Singleton{
        //在自己内部定义自己的一个实例,只供内部调用
        private static final Singleton instance = new Singleton();
        private Singleton(){
            //do something
        }
        //这里提供了一个供外部访问本class的静态方法,可以直接访问
        public static Singleton getInstance(){
            return instance;
        }
    }

    其中我们注意到,懒汉单例模式中getInstance方法有一个synchronized关键字,该关键字作用为当多个线程同时访问该方法的时候,必须等一个线程访问完,才能进行访问,这就预防了多个线程同时访问而创建多个实例。饿汉单例模式中instance属性被添加了final关键字,这就确保了该实例是个常量,不允许修改。

    展开全文
  • 单例模式有什么好处

    2018-06-08 10:08:51
    Java中用单例模式有什么好处Java Singleton模式主要作用是保证在Java应用程序中,一个类Class只有一个实例存在。 使用Singleton的好处还在于可以节省内存,因为它限制了实例的个数,有利于Java垃圾回收(garbage ...

    Java中用单例模式有什么好处

    Java Singleton模式主要作用是保证在Java应用程序中,一个类Class只有一个实例存在。 使用Singleton的好处还在于可以节省内存,因为它限制了实例的个数,有利于Java垃圾回收(garbage collection)。

    我们在浏览BBS、SNS网站的时候,常常会看到“当前在线人数”这样的一项内容。对于这样的一项功能,我们通常的做法是把当前的在线人数存放到一个内存、文件或者数据库中,每次用户登录的时候,就会马上从内存、文件或者数据库中取出,在其基础上加1后,作为当前的在线人数进行显示,然后再把它保存回内存、文件或者数据库里,这样后续登录的用户看到的就是更新后的当前在线人数;同样的道理,当用户退出后,当前在线人数进行减1的工作。所以,对于这样的一个需求,我们按照面向对象的设计思想,可以把它抽象为“在线计数器”这样一个对象。

    网站代码中凡是用到计数器的地方,只要new一个计数器对象,然后就可以获取、保存、增加或者减少在线人数的数量。不过,我们的代码实际的使用效果并不好。假如有多个用户同时登录,那么在这个时刻,通过计数器取到的在线人数是相同的,于是他们使用各自的计数器加1后存入文件或者数据库。这样操作后续登陆的用户得到的在线人数,与实际的在线人数并不一致。所以,把这个计数器设计为一个全局对象,所有人都共用同一份数据,就可以避免类似的问题,这就是我们所说的单例模式的其中的一种应用。

    单例模式能够保证一个类仅有唯一的实例,并提供一个全局访问点。

    我们是不是可以通过一个全局变量来实现单例模式的要求呢?我们只要仔细地想想看,全局变量确实可以提供一个全局访问点,但是它不能防止别人实例化多个对象。通过外部程序来控制的对象的产生的个数,势必会系统的增加管理成本,增大模块之间的耦合度。所以,最好的解决办法就是让类自己负责保存它的唯一实例,并且让这个类保证不会产生第二个实例,同时提供一个让外部对象访问该实例的方法。自己的事情自己办,而不是由别人代办,这非常符合面向对象的封装原则。

    单例模式主要有3个特点,:

    1、单例类确保自己只有一个实例。

    2、单例类必须自己创建自己的实例。

    3、单例类必须为其他对象提供唯一的实例。

    单例模式的实现方式:懒汉单例类和饿汉单例类

    单例模式的实现有多种方法,常见的就有懒汉式单例类和饿汉式单例类。我们前面介绍的实现方法就属于懒汉式单例类。

    · 懒汉式单例类

    对于懒汉模式,我们可以这样理解:该单例类非常懒,只有在自身需要的时候才会行动,从来不知道及早做好准备。它在需要对象的时候,才判断是否已有对象,如果没有就立即创建一个对象,然后返回,如果已有对象就不再创建,立即返回。

    懒汉模式只在外部对象第一次请求实例的时候才去创建。

    · 饿汉式单例

    对于饿汉模式,我们可以这样理解:该单例类非常饿,迫切需要吃东西,所以它在类加载的时候就立即创建对象。

    我们对比一下懒汉模式和饿汉模式的优缺点:

    懒汉模式,它的特点是运行时获得对象的速度比较慢,但加载类的时候比较快。它在整个应用的生命周期只有一部分时间在占用资源。

    饿汉模式,它的特点是加载类的时候比较慢,但运行时获得对象的速度比较快。它从加载到应用结束会一直占用资源。

    这两种模式对于初始化较快,占用资源少的轻量级对象来说,没有多大的性能差异,选择懒汉式还是饿汉式都没有问题。但是对于初始化慢,占用资源多的重量级对象来说,就会有比较明显的差别了。所以,对重量级对象应用饿汉模式,类加载时速度慢,但运行时速度快;懒汉模式则与之相反,类加载时速度快,但运行时第一次获得对象的速度慢。

    从用户体验的角度来说,我们应该首选饿汉模式。我们愿意等待某个程序花较长的时间初始化,却不喜欢在程序运行时等待太久,给人一种反应迟钝的感觉,所以对于有重量级对象参与的单例模式,我们推荐使用饿汉模式。

    而对于初始化较快的轻量级对象来说,选用哪种方法都可以。如果一个应用中使用了大量单例模式,我们就应该权衡两种方法了。轻量级对象的单例采用懒汉模式,减轻加载时的负担,缩短加载时间,提高加载效率;同时由于是轻量级对象,把这些对象的创建放在使用时进行,实际就是把创建单例对象所消耗的时间分摊到整个应用中去了,对于整个应用的运行效率没有太大影响。

    什么情况下使用单例模式

    单例模式也是一种比较常见的设计模式,它到底能带给我们什么好处呢?其实无非是三个方面的作用:

    第一、控制资源的使用,通过线程同步来控制资源的并发访问;

    第二、控制实例产生的数量,达到节约资源的目的。

    第三、作为通信媒介使用,也就是数据共享,它可以在不建立直接关联的条件下,让多个不相关的两个线程或者进程之间实现通信。

    比如,数据库连接池的设计一般采用单例模式,数据库连接是一种数据库资源。软件系统中使用数据库连接池,主要是节省打开或者关闭数据库连接所引起的效率损耗,这种效率上的损耗还是非常昂贵的。当然,使用数据库连接池还有很多其它的好处,可以屏蔽不同数据数据库之间的差异,实现系统对数据库的低度耦合,也可以被多个系统同时使用,具有高可复用性,还能方便对数据库连接的管理等等。数据库连接池属于重量级资源,一个应用中只需要保留一份即可,既节省了资源又方便管理。所以数据库连接池采用单例模式进行设计会是一个非常好的选择。

    在我们日常使用的在Windows中也有不少单例模式设计的组件,象常用的文件管理器。由于Windows操作系统是一个典型的多进程多线程系统,那么在创建或者删除某个文件的时候,就不可避免地出现多个进程或线程同时操作一个文件的现象。采用单例模式设计的文件管理器就可以完美的解决这个问题,所有的文件操作都必须通过唯一的实例进行,这样就不会产生混乱的现象。

    再比如,每台计算机可以有若干个打印机,如果每一个进程或者线程都独立地使用打印机资源的话,那么我们打印出来的结果就有可能既包含这个打印任务的一部分,又包含另外一个打印任务的一部分。所以,大多数的操作系统最终为打印任务设计了一个单例模式的假脱机服务Printer Spooler,所有的打印任务都需要通过假脱机服务进行。

    实际上,配置信息类、管理类、控制类、门面类、代理类通常被设计为单例类。像Java的Struts、Spring框架,.Net的Spring.Net框架,以及Php的Zend框架都大量使用了单例模式。

    详细内容请参考: 

    使用单例模式最核心的一点是体现了面向对象封装特性中的“单一职责”和“对象自治”原则。

    很多时候我们要保证类的实例只有一个。我们可能在自己的代码中判断需要的类的实例有无,无就new一个。这样看似不错。问题是,你用到这个类的地方有n个,这样你就需要n个判断。为什么不把这个职责交给类本身呢?然后让类提供一个接口访问。

    展开全文
  • 单例模式的定义与特点 单例模式的定义: 指一个类只有一个实例,且该类能自行创建这个实例的一种模式。...单例模式有三个特点: 单例类只有一个实例对象; 该单例对象必须由单例类自行创建; 单例类对外提供
  • 1.1单例模式特点 单例类只能一个实例。 单例类必须自己创建自己唯一的实例。 单例类必须给所有其他对象提供这个实例。 1.2 实现过程【懒汉】 第一次 /* * 1. 私有的构造方法 * 共有的话别人一调用就会新的...
  • 单例模式特点: 单例类只能一个实例 单例类必须自己创建自己的唯一实例 单例类必须给所有其他对象提供这一实例的访问 应用场景: 全局唯一类,如 系统配置类、系统硬件资源访问类 序列号生成器 ...
  • 1.1.1 摘要 ...单例模式(Singleton)是几个创建模式中最对立的一个,它的主要特点不是根据用户程序调用生成一个新的实例,而是控制某个类型的实例唯一性,通过上图我们知道它包含的角色只有一个,
  • 单例模式特点

    千次阅读 2018-07-10 17:10:30
    单例所具备的特点:1.私有化的构造函数2.私有的静态的全局变量3.公有的静态的方法单例分为懒汉式、饿汉式和双层锁式饿汉式:public class Singleton1 { private Singleton1() {}; private static Singleton1 single...
  • 文章目录单例模式创建方式各自特点前言单例模式定义单例的实现思路单例的好处单例模式的实现方式饿汉式优点缺点懒汉式优点缺点懒汉式-双重检验锁优点缺点静态内部类方式优点缺点枚举方式优点缺点破坏单例模式的方法...
  • Java中用单例模式有什么好处?

    千次阅读 2019-04-28 14:23:36
    JavaSingleton模式主要作用是保证在Java应用程序中,一个类Class只有一个实例存在。使用Singleton的好处还在于可以节省内存,因为它限制了实例的个数,有利于Java垃圾回收(garbagecollection)。 我们在浏览BBS、...
  • 单例模式详解一、单例模式的定义及应用场景二、饿汉式单例模式(一)、饿汉式单例模式的优缺点(二)、饿汉式单例模式的代码案例三、懒汉式单例模式(一)、懒汉式单例模式特点(二)、懒汉式单例模式的代码案例一...
  • 1.什么单例模式 2.单例模式解决的问题 3.单例模式特点 4.单例模式的优点 5.单例模式的缺点 6.实现单例模式的方式 6.1 饿汉式 6.2 懒汉式(线程不安全写法) 6.3 懒汉式(线程安全写法) 6.3.1 锁方法 ...
  • 单例模式例子

    2012-10-28 20:24:52
    java模式之单例模式单例模式确保一个类只有一个实例,自行提供这个实例并向整个系统提供这个实例。 特点: 1,一个类只能一个实例 2,自己创建这个实例 3,整个系统都要使用这个实例 例: 在下面的对象图...
  • 单例模式也是创建型模式的一种,在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中,应用该模式的一个类只有一个实例,而且自行实例化并且向整个系统提供这个实例。该类构造方法为私有,并...
  • 单例模式的定义与特点 单例(Singleton)模式的定义:指一个类只有一个实例,且该类能自行创建这个实例的一种模式。例如,Windows 中只能打开一个任务管理器,这样可以避免因打开多个任务管理器窗口而造成内存资源的...
  • PHP单例模式详细介绍

    2020-12-18 04:40:05
    单例模式特点 单例模式的主要特点是“三私一公”: 需要一个保存类的唯一实例的私有静态成员变量 构造函数必须声明为私有的,防止外部程序new一个对象从而失去单例的意义 克隆函数必须声明为私有的,防止对象被...
  • 设计模式-单例模式

    2021-02-02 13:59:07
    单例模式有三个特点: 单例类只有一个对象 该单例对象必须由单例类自行创建 单例类对外提供一个访问该单例的全局访问点 单例模式优缺点 优点 单例模式可以保证内存里只有一个实例,减少了内存的开销 可以避免对...
  • C#单例模式

    2019-05-28 19:20:11
    1、什么是单例单例模式(Singleton)是几个创建模式中最对立的一个,它的主要特点不是根据用户程序调用生成一个新的实例,而是控制某个类型的实例唯一性,通过上图我们知道它包含的角色只有一个,就是Singleton,它...
  • JAVA设计模式之单例模式

    万次阅读 多人点赞 2014-04-16 06:51:34
     单例模式有以下特点:  1、单例类只能一个实例。  2、单例类必须自己创建自己的唯一实例。  3、单例类必须给所有其他对象提供这一实例。 单例模式确保某个类只有一个实例,而且自行实例化并向整个系统提供这...
  • 单例模式特点: 1、单例类只能创建一个实例。 2、单例类必须自己创建自己的唯一实例。 3、单例类必须给其他所有对象提供这一实例。 饿汉式与懒汉式的区别: 1、时间和空间 懒汉式是典型的时间换空间,也就是每次...
  • 单例模式

    千次阅读 2018-05-24 13:53:04
    单例模式是比较常见的设计模式。最简单的编写方法:```Javapublic class Singleton(){public static Singleton sInstance = null;//构造函数声明为private,是阻止外部实例化这个类。因为默认无参数构造方法是public...
  • 单例模式之枚举实现

    千次阅读 多人点赞 2020-12-10 20:47:51
    很多网友留言说我漏掉了一种非常重要的Java语言的单例模式实现方式——枚举。 这篇姗姗来迟的博文将弥补这个“巨大的”缺陷。 在Java语言中,如果综合考虑线程安全和延迟加载,IoDH(Initialization Demand ...
  • (1)单例模式特点什么是单例模式)?  a.单例类只能一个实例。  b.单例类必须自己创建自己的唯一实例。  c.单例类必须给所有其他对象提供这一实例。 (2)单例模式的作用(用单例模式的目的)? Singleton模式...
  • 你知道多少种方式实现单例模式

    千次阅读 多人点赞 2019-11-29 21:09:09
    单例模式是应用最广的模式之一,也是最简单的模式,但越是简单的东西,就越容易忽略它的细节,在应用这个模式时,同一个进程内,单例对象的类必须保证只有一个实例存在,比如在一个应用中,应该只有一个ImagerLoader...
  • 单例模式的主要特点是“三私一公”: 需要一个保存类的唯一实例的私有静态成员变量 构造函数必须声明为私有的,防止外部程序new一个对象从而失去单例的意义 克隆函数必须声明为私有的,防止对象被克隆 必须提供...
  • 单例模式 单例模式(Singleton Pattern):确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例,这个类称为单例类,它提供全局访问的方法。单例模式是一种对象创建型模式。在单例类的内部实现只生成一...
  •  单例模式有以下特点:  1、单例类只能一个实例。  2、单例类必须自己创建自己的唯一实例。  3、单例类必须给所有其他对象提供这一实例。   一、懒汉式单例 //懒汉式单例类.在第一次调用的时候实例化自己 ...
  • 设计模式——1、单例模式

    千次阅读 2021-02-01 15:53:55
    单例模式的定义与特点 单例(Singleton)模式的定义:指一个类只有一个实例,且该类能自行创建这个实例的一种模式。例如,Windows 中只能打开一个任务管理器,这样可以避免因打开多个任务管理器窗口而造成内存资源...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 56,999
精华内容 22,799
关键字:

单例模式有什么特点