2. 程式人生 > >php如何實現單例模式

php如何實現單例模式

阿新 • • 發佈：2019-02-10

凡是講到設計模式，無一例外的都會講到單例模式，單例模式相對於其他設計模式來講，要容易理解的多，但是要實現一個嚴格意義上的單例模式，很簡單嗎？

很多人可以輕鬆的寫出如下php實現的單例模式：

<?php

class Singleton {
    //儲存類例項的靜態成員變數
    private static $_instance;

    //private 建構函式
    private function __construct() {
        echo " I'm construct! process id is " . getmypid() . " and thread id is " . Thread::getCurrentThreadId() . "\n";
    }

    private function __clone() {
        echo " I'm clone! process id is " . getmypid() . " and thread id is " . Thread::getCurrentThreadId() . "\n";
    }

    //單例方法訪問類例項
    public static function getInstance() {
        if (!(self::$_instance instanceof self)) {
            self::$_instance = new self();
        }
        return self::$_instance;
    }
}

在該示例中，將構造方法設為private從而防止直接new一個物件；將__clone方法設為private，防止通過clone複製一個物件；需要該類物件"只能"通過呼叫Singleton::getInstance()方法的方式，而getInstance方法通過"餓漢模式"保證類變數$_instance只會被初始化一次，即Singleton類只能有一個物件。

這種實現方式看似沒有問題，當我們試圖 new Singleton()或者clone 一個物件時都會發生fatal error。那麼，這種方式是否就能保證單例了？並不是。

考慮反射

構造方法被private了，是不是就無法例項化一個類了？來看ReflectionClass的一個方法

ReflectionClass::newInstanceWithoutConstructor — 建立一個新的類例項而不呼叫它的建構函式

也就是通過這個方法可以不經過構造方法就建立一個物件，上例中試圖將構造方法private來阻止例項物件的方法失效了。下面來驗證可行性。

為了方便驗證，會在上例中加入一些屬性及方法。

<?php

class Singleton {
    //儲存類例項的靜態成員變數
    private static $_instance;
    private $_serialize_id = 1234567890;

    //private 建構函式
    private function __construct() {
        $this->setSerializeId(rand(1,1000000000000));
        echo $this . " I'm construct! process id is " . getmypid() . " and thread id is " . Thread::getCurrentThreadId() . "\n";
    }

    private function __clone() {
        echo $this . " I'm clone! process id is " . getmypid() . " and thread id is " . Thread::getCurrentThreadId() . "\n";
    }

    /**
     * @return mixed
     */
    public function getSerializeId() {
        return $this->_serialize_id;
    }

    /**
     * @param mixed $serialize_id
     */
    public function setSerializeId($serialize_id) {
        $this->_serialize_id = $serialize_id;
    }

    //單例方法訪問類例項
    public static function getInstance() {
        if (!(self::$_instance instanceof self)) {
            self::$_instance = new self();
        }
        return self::$_instance;
    }
    public function __toString()
    {
        return __CLASS__ . " " . $this->getSerializeId() ;
    }
}


測試用例指令碼：

<?php
require_once 'singleton.php';

//$obj1 and $obj3 is the same object

$obj1 = Singleton::getInstance();
$obj3 = Singleton::getInstance();

//$obj2 is a new object
$class = new ReflectionClass('Singleton');
$obj2 = $class->newInstanceWithoutConstructor();
$ctor = $class->getConstructor();
$ctor->setAccessible(true);
$ctor->invoke($obj2);

echo "obj1 equal to obj3: " . ($obj1 === $obj3) . "\n";
echo "obj1 not equal obj2: " . ($obj1 !== $obj2) . "\n";

xdebug_debug_zval('obj1');
xdebug_debug_zval('obj2');
xdebug_debug_zval('obj3');

輸出case：

Singleton 840562594589 I'm construct! process id is 30019 and thread id is 140410609465280
Singleton 920373440721 I'm construct! process id is 30019 and thread id is 140410609465280
obj1 equal to obj3: 1
obj1 not equal obj2: 1
obj1: (refcount=3, is_ref=0)=class Singleton { private $_serialize_id = (refcount=1, is_ref=0)=840562594589 }
obj2: (refcount=1, is_ref=0)=class Singleton { private $_serialize_id = (refcount=1, is_ref=0)=920373440721 }
obj3: (refcount=3, is_ref=0)=class Singleton { private $_serialize_id = (refcount=1, is_ref=0)=840562594589 }


可以看出$obj1和$obj3是同一個物件，而與$obj2則是不同的物件。違反了單例模式。


考慮序列化

<?php
require_once 'singleton.php';

//$obj1 and $obj3 is the same object

$obj1 = Singleton::getInstance();
$obj3 = Singleton::getInstance();

//$obj2 is a new object
$objSer = serialize($obj1);
$obj2 = unserialize($objSer);

echo "obj1 equal to obj3: " . ($obj1 === $obj3) . "\n";
echo "obj1 not equal obj2: " . ($obj1 !== $obj2) . "\n";

xdebug_debug_zval('obj1');
xdebug_debug_zval('obj2');
xdebug_debug_zval('obj3');

輸出case：

Singleton 165926147718 I'm construct! process id is 6849 and thread id is 139844633716672
obj1 equal to obj3: 1
obj1 not equal obj2: 1
obj1: (refcount=3, is_ref=0)=class Singleton { private $_serialize_id = (refcount=1, is_ref=0)=165926147718 }
obj2: (refcount=1, is_ref=0)=class Singleton { private $_serialize_id = (refcount=1, is_ref=0)=165926147718 }
obj3: (refcount=3, is_ref=0)=class Singleton { private $_serialize_id = (refcount=1, is_ref=0)=165926147718 }


可以看出$obj1和$obj3是同一個物件，而與$obj2則是不同的物件。違反了單例模式。


考慮多執行緒

<?php
require_once 'singleton.php';
class Mythread extends Thread {
    public function __construct($i) {
        $this->i = $i; 
    }   
    public function run() {
        $obj = Singleton::getInstance();
        xdebug_debug_zval('obj');
    }   
}

for ( $i=1; $i<10; $i++) {
    $threads[$i]=new MyThread($i);
    $threads[$i]->start();
}

輸出case 
Singleton 685692620930 I'm construct! process id is 27349 and thread id is 139824163313408
obj: (refcount=2, is_ref=0)=class Singleton { private $_serialize_id = (refcount=1, is_ref=0)=685692620930 }
Singleton 578721798491 I'm construct! process id is 27349 and thread id is 139824152233728
obj: (refcount=2, is_ref=0)=class Singleton { private $_serialize_id = (refcount=1, is_ref=0)=578721798491 }
Singleton 334907566198 I'm construct! process id is 27349 and thread id is 139824069605120
obj: (refcount=2, is_ref=0)=class Singleton { private $_serialize_id = (refcount=1, is_ref=0)=334907566198 }
Singleton 940285742749 I'm construct! process id is 27349 and thread id is 139824059115264
obj: (refcount=2, is_ref=0)=class Singleton { private $_serialize_id = (refcount=1, is_ref=0)=940285742749 }
Singleton 41907731444 I'm construct! process id is 27349 and thread id is 139824048625408
obj: (refcount=2, is_ref=0)=class Singleton { private $_serialize_id = (refcount=1, is_ref=0)=41907731444 }
Singleton 492959984113 I'm construct! process id is 27349 and thread id is 139824038135552
obj: (refcount=2, is_ref=0)=class Singleton { private $_serialize_id = (refcount=1, is_ref=0)=492959984113 }
Singleton 561926315539 I'm construct! process id is 27349 and thread id is 139824027645696
obj: (refcount=2, is_ref=0)=class Singleton { private $_serialize_id = (refcount=1, is_ref=0)=561926315539 }
Singleton 829729639926 I'm construct! process id is 27349 and thread id is 139824017155840
obj: (refcount=2, is_ref=0)=class Singleton { private $_serialize_id = (refcount=1, is_ref=0)=829729639926 }
Singleton 435530856252 I'm construct! process id is 27349 and thread id is 139823935387392
obj: (refcount=2, is_ref=0)=class Singleton { private $_serialize_id = (refcount=1, is_ref=0)=435530856252 }


目前可以想到以上三種可以破壞上述單例模式的情形，下面針對上述三個方面，試著探討一些相應的解決方案。

針對反射

設定標誌位，第一次呼叫建構函式時開啟標誌位，第二次呼叫建構函式時丟擲異常。

<?php

class Singleton {
    //儲存類例項的靜態成員變數
    private static $_instance;
    private $_serialize_id = 1234567890;
    private static $_flag = false;

    //private 建構函式
    private function __construct() {
        if ( self::$_flag ) {
            throw new Exception("I'm Singleton");
        }
        else {
            self::$_flag = true;
        }
        $this->setSerializeId(rand(1,1000000000000));
        echo $this . " I'm construct! process id is " . getmypid() . " and thread id is " . Thread::getCurrentThreadId() . "\n";
    }

    private function __clone() {
        echo $this . " I'm clone! process id is " . getmypid() . " and thread id is " . Thread::getCurrentThreadId() . "\n";
    }

    /**
     * @return mixed
     */
    public function getSerializeId() {
        return $this->_serialize_id;
    }

    /**
     * @param mixed $serialize_id
     */
    public function setSerializeId($serialize_id) {
        $this->_serialize_id = $serialize_id;
    }

    //單例方法訪問類例項
    public static function getInstance() {
        if (!(self::$_instance instanceof self)) {
            self::$_instance = new self();
        }
        return self::$_instance;
    }
    public function __toString()
    {
        return __CLASS__ . " " . $this->getSerializeId() ;
    }
}


針對序列化

由於在序列化之前會試圖呼叫__sleep()方法，相應的，在重新構造物件之後，會呼叫__wakeup()方法。與__clone()方法不同，序列化的時候__sleep()方法只是序列化動作之前呼叫，將其設定為private並不會起作用，只是執行的時候會收到一個notice。可以試著在__sleep()方法丟擲異常的方式來阻止序列化的達成。不過使用這種方式，如果沒有捕獲異常，或者沒有異常處理函式，將導致程式異常退出，並不是很完美。

在Singleton類中增加__sleep()及__wakeup()方法，並執行測試case

Singleton 594976518769 I'm construct! process id is 27612 and thread id is 139941710354368

PHP Fatal error:  Uncaught exception 'Exception' with message 'Not allowed serizlization' in /data1/study/php/singleton.php:44
Stack trace:
#0 [internal function]: Singleton->__sleep()
#1 /data1/study/php/test2.php(11): serialize(Object(Singleton))
#2 {main}
  thrown in /data1/study/php/singleton.php on line 44

Fatal error: Uncaught exception 'Exception' with message 'Not allowed serizlization' in /data1/study/php/singleton.php on line 44

Exception: Not allowed serizlization in /data1/study/php/singleton.php on line 44

Call Stack:
    0.0007     227224   1. {main}() /data1/study/php/test2.php:0
    0.0010     244080   2. serialize(???) /data1/study/php/test2.php:11
    0.0010     244448   3. Singleton->__sleep() /data1/study/php/test2.php:11

在這個測試case中，發現了另外一個問題，《php中$this的引用計數》

針對多執行緒

目前還沒有想到針對多執行緒的解決方案。

單例模式與trait結合，可以實現一個單例模式的模板，關於php中trait的使用參見《php中的trait》

<?php

trait TSingleton {
    private $_serialize_id = 1234567890;
    private static $_flag = false ;
    //private 建構函式
    private function __construct() {
        if ( self::$_flag ) {
            throw new Exception("I'm a Singleton");
        } 
        else {
            self::$_flag = true;
        }
        $this->setSerializeId(rand(1,1000000000000));
        echo $this . " I'm construct! process id is " . getmypid() . " and thread id is " . Thread::getCurrentThreadId() . "\n";
    }
    private function __clone() {
        echo $this . " I'm clone! process id is " . getmypid() . " and thread id is " . Thread::getCurrentThreadId() . "\n";
    }

    /**
     * @return mixed
     */
    public function getSerializeId() {
        return $this->_serialize_id;
    }

    /**
     * @param mixed $serialize_id
     */
    public function setSerializeId($serialize_id) {
        $this->_serialize_id = $serialize_id;
    }

    //單例方法訪問類例項
    public static function getInstance() {
        static $instance ;
        if (!($instance instanceof self )) {
            $ref = new ReflectionClass( get_called_class() );
            $ctor = $ref->getConstructor();
            $ctor->setAccessible(true);
            $instance = $ref->newInstanceWithoutConstructor();
            $ctor->invokeArgs($instance, func_get_args());
        }
        return $instance;
    }
    public function __toString()
    {
        return __CLASS__ . " " . $this->getSerializeId() ;
    }
    
    public function __sleep()
    {
        // TODO: Implement __sleep() method.
        throw new Exception("I'm Singleton! Can't serialize");
    }
    
    public function __wakeup()
    {
        // TODO: Implement __wakeup() method.
        throw new Exception("I'm Singleton! Can't unserialize");
    }
}

class Singleton {
    use TSingleton;
}



相關推薦

PHP中單例模式實現

  class SingleInstance{                private function _construct(){                    }               private static $instance;              private fun

php如何實現單例模式

凡是講到設計模式，無一例外的都會講到單例模式，單例模式相對於其他設計模式來講，要容易理解的多，但是要實現一個嚴格意義上的單例模式，很簡單嗎？ 很多人可以輕鬆的寫出如下php實現的單例模式： <?php class Singleton { //儲存類例項的靜

溫故而知新(java實現)單例模式的七種寫法

反序 防止 代碼 工作 html 我想 變種 evel 才會 第一種（懶漢，線程不安全）： Java代碼 public class Singleton { private static Singleton instance; private S

php的單例模式

code 單例模式 內部 class 資源管理 資源 log 限制 cti 單例模式：指的是一個對象的模式，指一個類只能創建一個對象。 既然限制一個類只能創建一個對象，就是說要關閉其他創建對象的途徑。 所以實現單例，必須滿足一下條件: 1.不讓克隆（私有克隆方法） 2.不讓

Java枚舉enum以及應用：枚舉實現單例模式

tee configure adr 自由 這樣的 pre 單例模式 做到 build 枚舉作為一個常規的語言概念，一直到Java5才誕生不得不說有點奇怪，以至於到現在為止很多程序員仍然更喜歡用static final的形式去命名常量而不使用，一般情況下，Java程序員用這種

Python 實現單例模式

python 單例模式 Python 實現單例模式 # 使用Python實現單例模式 # 方法一: 使用__new__方法 class SingleTon(object): def __new__(cls, *args, **kwargs): if not ha

使用靜態代碼塊來實現單例模式

對象 代碼 over 說明 override out min .get admin package com.wz.thread.staticlump;/** * 使用靜態代碼塊來實現單例模式 * @author Administrator * */public class

枚舉實現單例模式

min () bject oca serve oid ros manager [] package com.wz.thread.enums;import java.sql.Connection;import java.sql.DriverManager;/** * 使用枚舉

python實現單例模式

一次 color 中大 我們 浪費 python實現 判斷 內存 () 有這麽一種場景，我們把數據封裝到類體或類的某個方法裏，然而我們new出這個類只是為了拿到這部分數據，那麽當多次這樣調用的時候，每次都來拿數據並放到內存中大大浪費了內存。 那我們就可以想，我們拿到一次數據

python3實現單例模式

單例模式 python3 單例模式指確保某個類在整個系統中只存在一個實例的一種設計模式使用單例模式的好處：1、每個實例都會占用一定的內存資源，且初始化實例時會影響運行性能，所以當整個系統只需一個實例時，使用單例模式不僅可減少資源占用，而且因為只初始化一次，還可以加快運行性能。例如當程序通過一個類來讀取

雙重檢查鎖實現單例模式的線程安全問題

多線程 urn blog 內存 http 代碼 地方 gets 技術博客 一、結論 雙重校驗鎖的單例模式代碼如下： public class Singleton { 　　private static Singleton singleton; 　　private Singl

python 使用裝飾器實現單例模式

1、裝飾器 python中一切皆物件，同樣函式也是一個物件。函式物件有一個__name__屬性，可以檢視函式的名字。   def demo(): print("xxx") print(demo.__name__) output: demo 假設我們要增強函式dem

AtomicReference實現單例模式

  CAS是項樂觀鎖技術，當多個執行緒嘗試使用CAS同時更新同一個變數時，只有其中一個執行緒能更新變數的值，而其它執行緒都失敗，失敗的執行緒並不會被掛起，而是被告知這次競爭中失敗，並可以再次嘗試。 樂觀鎖的一種實現方式——CAS 在JDK1.5 中新增java.util.concurrent(

使用boost庫實現單例模式

單例模式是最常使用的設計模式之一，特別在跨檔案程式設計時使用的最多。 #include<boost/noncopyable.hpp> #include<pthread.h> #include<stdlib.h> template<typename T

php設計單例模式，一次只能產生一個物件

單例即單個物件，一次只能生產一個物件，程式碼如下 class Single{  // 定義一個類  static private $instance=null; // 宣告一個靜態屬性，因為靜態屬性的資料具有長期性 且僅能為類所呼叫 所以這個靜態屬性用來儲存物件。

php之單例模式，工廠模式，註冊模式

工廠模式是通過類或者工廠方法來產生物件，而不是在程式碼中直接new; 上面將例項化物件的方法封裝到工廠類中，比如當例項化物件的名稱發生改變時只需要更改工廠類中的方法。如果不封裝到工廠類中就需要一個一個的去new的地方更改new的物件名稱。 工廠模式說白了就是一種程式設計規範，是一

php實現單例類工廠--傳遞同一個類名只產生僅僅一個物件

單例類工廠 用來傳遞類，併產生相應的單例物件，但是物件需要引入這個ModelFacetory類檔案以及通過ModelFacetory：：M(類名)這種方式來直接例項化 獲得物件. class ModelFactory{ static $class_instance=array();  

設計模式一（php示例 單例模式和工廠模式）

所謂的設計模式，就是具有多年開發經驗的人，在實際工作中為了解決某一種需求，而形成的一套程式碼方案。 1.單例模式： 單例模式：所謂的單例模式就是單一的例項。通過一個類永遠只能獲取一個物件。 基本的實現思路：單例模式要求類能夠有返回物件一個引用(永遠是同一個)和一個獲得該例項的方法（必

用單例物件實現單例模式

2018-12-04 14:55:07 object SingletonDemo { //object修飾的為物件 def main(args: Array[String]): Unit = { val s = SessionFactory println(s.getS

PHP的單例模式 ，工廠模式，註冊模式的例子

<?php /** * Created by PhpStorm. * User: * Date: 2018/12/6 * Time: 14:11 */ class Site { //屬性 public $siteName; //本類的靜態例項