设计方式-单例方式(02),设计形式例形式02

发布时间:2019-01-25  栏目:Python  评论:0 Comments

单利模式的核心点在于只能生成1个对象,并且是由类中的静态变量保存。

以下代码来自《深入PHP 面向对象、模式与实践》(第三版)第9章

/**
 * Created by PhpStorm.
 * User: Eilen
 * Date: 2018/8/31
 * Time: 22:48
 */

class Preferences
{
    private $props = array();
    private static $instance;

    private function __construct(){}

    /**
     * 获取单例模式对象
     * @return mixed
     */
    public static function getInstance()
    {
        if (empty(self::$instance)){
            self::$instance = new Preferences();
        }
        return self::$instance;
    }

    /**
     * 接收对象的参数,并且赋值
     * @param $key
     * @param $val
     */
    public function setProperty($key, $val)
    {
        $this->props[$key] = $val;
    }

    public function getProperty($key)
    {
        return $this->props[$key];
    }
}

//引用单例模式

$pref = Preferences::getInstance();
$pref->setProperty('name', 'matt');

unset($pref);

$pref2 = Preferences::getInstance();
print $pref2->getProperty('name');

设计方式-单例方式(02),设计形式例格局02

定义

  单例方式(Singleton Pattern)是最简易的一种设计情势。
  英文原话是:Ensure a class has only one instance,and provide a
global point of access to it.
  意思是:确保一个类唯有一个实例,而且自动实例化并向任何系统提供那一个实例。

  单例格局的重中之重功能是承保一个类唯有一个实例存在。单例情势可以用在创设目录,数据库连接等急需单线程操作的场面,用于落到实处对系统资源的控制。

分类

  Java语言的特性使得在Java中贯彻单例形式寻常有三种表现方式:

  饿汉式单例类:类加载时,就进展对象实例化。
  懒汉式单例类:第四遍引用类时,才进行对象实例化。

  饿汉式单例类

  饿汉式代码如下:

public class Singleton{
    private static Singleton m_instance = new Singleton();
    //构造方法私有,保证外界无法直接实例化
    private Singleton(){
    }
    //通过该方法获得实例对象
    public static Singleton getInstance(){
        return m_instance;
    }        
}

     
上面那段代码中,在类加载时,静态变量m_instance会被起头化,此时类的私家构造函数会被调用,单例类的绝无仅有实例就被成立出来。单例类中最重点的特点是类的构造函数是私有的,从而幸免外界利用构造函数直接成立出任意多的实例。此外,构造函数是个体的,因而该类不可能被延续。

  懒汉式单例类

  懒汉式单例类与饿汉式单例类相同的是,类的构造函数是私房的;分歧的是,懒汉式单例类在加载时不会将团结实例化,而是在率先次被调用时将自己实例化。

  懒汉式代码如下:

 

public class Singleton{
    private static Singleton _instance = null;
    //构造方法私有,保证外界无法直接实例化
    private Singleton(){
    }    
    //方法同步
    synchronized public static Singleton getInstance(){
        if(_instance==null){
            _instance = new  Singleton();
        }
        return _instance;
    }
}

  上边那段代码中,懒汉式单例类中对静态方法getInstance()举办共同,以管教十二线程环境下只开创一个实例。例如:假若getInstance()方法未被一起,并且线程A和线程B同时调用此措施,则实施if(_instance==null)语句时都为真,线程A和线程B会分别创立一个目的,在内存中就会现出七个目的,那样就违背了单例方式;单运用synchronized关键字展开同步后,就不会并发那种情景了。

  饿汉式单例类与懒汉式单例类之间的区别

  1.懒汉式单例类在被加载时实例化,而懒汉式单例类在第二回引用时实例化。
  2.从资源利用上说,饿汉式单例类比懒汉式单例类要差点(因为饿汉式一早先就会实例化一个目的占用系统资源),但从速度和反应时间角度来讲,则饿汉式单例类比懒汉式单例类好一些。

  3.饿汉式单例类可以在Java中达成,但正确在C++中完成。GoF在提议单利情势的概念是举的例证是懒汉式的,他们的书影响较大,以至于Java中单例类的事例大多是懒汉式的。实际上,饿汉式单例类更合乎Java语言本身的表征。

单例对象的独到之处

  1.出于单例格局在内存中唯有一个实例,减少了内存的开支,越发是当一个对象必要频仍地被创制、销毁而且创立或销毁的属性又力不从心优化时,单例格局的优势就丰富显眼。
  2.是因为单例方式值生成一个实例,所以收缩了系统的习性花费,当一个对象的暴发需要相比多的资源时,如读取配置文件、发生其余信赖对象时,可以在启动时直接爆发一个单例对象,然后永久驻留内存的章程来缓解。
  3.单例方式可以防止对资源的一种类占用。例如:一个写文件动作,由于唯有一个实例存在于内存中,防止了对同一个资源文件的还要写操作。
    4.单例方式能够在系统装置全局访问点,优化和共享资源访问。

单例情势的短处

  1.单例形式不可能创制子类,且扩张困难。若要扩充,除了修改代码以外基本上没有第二种途径得以兑现。
  2.单例方式对测试不利。在交互开发环境中,要是采取单例格局的类没有马到成功,程序是无法展开测试的;单例格局的类常见不会促成接口,那也妨碍了动用mock的办法虚拟一个对象。
  3.单例形式与纯粹职务规范有冲突。一个类应该只兑现一个逻辑,而不关切它是还是不是是单例的,是不是接纳单例格局取决于环境,单例形式。

单例方式的行使情状

  在一个种类中,要是要求一个类有且仅有一个实例,当出现四个实例时就会造成不良反应,则此时得以运用单例方式。典型气象如下:

  1.渴求扭转唯一种类号的条件。
  2.在方方面面项目中要求一个访问点或共享数据。(如web页面上的计数器)
  3.创设一个对象要求成本的资源过多,如访问IO和数据库等资源。
  4.需要定义多量的静态常量和静态方法(如工具类)的条件,可以运用单例格局。

那是一个误导人的线程例子,经过改动后.就变得很简单.

public class CounterSingleton {
    //懒汉式加载
    private static CounterSingleton singleton = new CounterSingleton();
    //私有构造,防止生成对象
    private CounterSingleton() {
    }
    //获取类
    public static CounterSingleton getInstance() {
        return singleton;
    }
    //对象的私有变量
    public int count = 0;
    //懒汉式对象的方法
    public synchronized void inc() {        
        //加访问量
        count++;
        //System.out.println(count);
    }

      public int getCount() {
        return count;
      }

}

public class Counter {
    public static void main(String[] args) {
        long time_s=System.currentTimeMillis();
        //同时启动1000个线程,去进行i++计算,看看实际结果
        for (int i = 0; i < 1000; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    CounterSingleton.getInstance().inc();
                }
            }).start();
        }

        //这里每次运行的值都有可能不同,显示结果可能不为1000(inc方法没有sychonized的话,count就是真的不是1000了)
        System.out.println("运行结果:CounterSingleton.count=" + CounterSingleton.getInstance().getCount());
        System.out.println("耗时:"+(System.currentTimeMillis()-time_s));
    }
}

源码

http://www.bkjia.com/Javabc/1232484.htmlwww.bkjia.comtruehttp://www.bkjia.com/Javabc/1232484.htmlTechArticle设计模式-单例模式(02),设计模式例模式02 定义
单例形式(Singleton Pattern)是最简便易行的一种设计情势。 英文原话是:Ensure
a class has only one…

留下评论

网站地图xml地图