转载自longlong's blog

在PHP中，没有普遍意义上的静态变量。与Java、C++不同，PHP中的静态变量的存活周期仅仅是每次PHP的会话周期，所以注定了不会有Java或者C++那种静态变量。
所以，在PHP中，静态变量的存在意义仅仅是在某个结构体中（方法或者类）中传递一个变量。
看个例子好了
  
 
  
  1. <?php 
  2. function test(){ 
  3.     static $var = 1; 
  4.     echo $var++.'<br />'; 
  5. } 
  6. test(); 
  7. test(); 
  8. test(); 
  9.  
  10. //OutPut 
  11. //1 
  12. //2 
  13. //3 
  14. ?> 
 
  

      
  
 
  

    在函数test的三次调用中，变量$var在三次调用中都是存在的，并且每次会递增1，而并没有清空或者重置 
  
 
  

    所以可以得出一个结论，静态变量在当前结构体所在的生命周期中一直存在。当前的例子中，test函数的生命周期就是当前PHP脚本（好像所有的都是吧！） 
  
 
  

    而在类中，代码大概是这样子的 
  
 
  

      
  
 
  
 
  
  1. <?php 
  2. class A 
  3. { 
  4.     private static $a = 1; 
  5.     private $b = 2; 
  6.     public function add() 
  7.     { 
  8.         echo self::$a++.'<br />'; 
  9.         echo $this->b++.'<br />'; 
  10.     } 
  11. } 
  12. $class1 = new A(); 
  13. $class1->add(); 
  14. $class1->add(); 
  15. $class2 = new A(); 
  16. $class2->add(); 
  17. $class2->add(); 
  18. //Output 
  19. //1 
  20. //2 
  21. //2 
  22. //3 
  23. //3 
  24. //2 
  25. //4 
  26. //3 
 
  

      
  
 
  

    从上面的类的运行结果来看，也得到了在函数中相同的结果 
  
 
  

    那么大概总结一下就是 
  
 
  

    PHP的静态变量在所在对应的结构体的生命周期中永久存在，并且值保持一致，不论这个结构体被调用或者实例化了多少次 
  
 
  

      
  
 
  

    再反过来看单例模式 
  
 
  

      
  
 
  
 
  
  1. <?php 
  2. class A 
  3. { 
  4.     private static $instance = null; 
  5.     private $b = 1; 
  6.     public static function get_instance() 
  7.     { 
  8.         if(self::$instance == null){ 
  9.             $classname = __CLASS__; 
  10.             self::$instance = new $classname(); 
  11.         } 
  12.         return self::$instance; 
  13.     } 
  14.     public function add() 
  15.     { 
  16.         $this->b++; 
  17.     } 
  18.     public function show() 
  19.     { 
  20.         echo $this->b; 
  21.     } 
  22. } 
  23. $a = A::get_instance(); 
  24. $b = A::get_instance(); 
  25. //此处$a和$b 变量完全相同！ 
  26. $a->add(); 
  27. $a->show(); 
  28. echo '<br />'; 
  29. $b->show(); 
  30. //output 
  31. //2 
  32. //2 
 
  

    此时，由于单例模式存在，使得$a和$b完全是同一个对象，所以之间如果需要共享数据，完全不需要静态变量（废话，就是自己！） 
  
 
  

    所以，在单例模式中，静态变量根本就没有存在的意义。当然，如果你没事干，非要使用new方法来初始化对象的话，也行，此时单例模式被打破，回归到无单例模式的状态。 
  
 
  

    如果为了防止使用new来实例化对象，那么可以考虑对类的__construct函数设置为private属性 
  
 
  

      
  
 
  
 
  
  1. <?php 
  2. class A 
  3. { 
  4.     private static $instance = null; 
  5.     private $b = 1; 
  6.     private function __construct() 
  7.     { 
  8.     //Code in this function 
  9.     //could not be get out of the class 
  10.     } 
  11.     public static function get_instance() 
  12.     { 
  13.         if(self::$instance == null){ 
  14.             $classname = __CLASS__; 
  15.             self::$instance = new $classname(); 
  16.         } 
  17.         return self::$instance; 
  18.     } 
  19.     public function add() 
  20.     { 
  21.         $this->b++; 
  22.     } 
  23.     public function show() 
  24.     { 
  25.         echo $this->b; 
  26.     } 
  27. } 
  28. $a = A::get_instance(); 
  29. $b = A::get_instance(); 
  30. //此处$a和$b 变量完全相同！ 
  31. $a->add(); 
  32. $a->show(); 
  33. echo '<br />'; 
  34. $b->show(); 
  35. //output 
  36. //2 
  37. //2 
 
  

      
  
 
  

    //如果尝试用new来实例化的话 
  
 
  

    $c = new A(); 
  
 
  

    //output 
  
 
  

    //Fatal error: Call to private A::__construct() from invalid context in 
  
 
  

    //如果需要A类的实例化对象，只能通过开放的get_instance静态方法进行初始化