एक PHP/pthreads थ्रेड क्लास सरणी का उपयोग नहीं कर सकता है?

Question

मुझे एक पीईसीएल पाथ्रेड Thread एक सरणी वस्तु का उपयोग नहीं कर सकता है। कारण खोजने के लिए मैं क्या कर सकता हूं?

कोड उदाहरण:

class my extends Thread { 

      public function __construct() { 
        $this->arr = array(); 
        $this->id = 0; 
      } 
      pulbic function run() { 
        while (true) { 
          $this->wait(); 
        } 
      } 

      public function set() { 
        $this->id = rand(0, 1000); 
        $this->arr[] = rand(0, 1000); 
        var_dump($this->id);//this is rand 
        var_dump($this->arr);//this is empty array() 
        $this->notify(); 
      } 
    } 

    $my = new my(); 
    $my->start(); 
    while (true) { 
      sleep(1); 
      $my->add(); 
    } 

Answer 1

समस्या

पीएचपी एक साझा कुछ भी नहीं माहौल है: इसका मतलब है कि प्रत्येक प्रक्रिया (या धागा) यह दुभाषिये की स्वयं की प्रतिलिपि, सभी मॉड्यूल, और उपयोगकर्ता होना आवश्यक है कोड।

HashTable संरचना जो न केवल PHP सरणी का समर्थन करती है, लेकिन पूरे PHP कोड बेस में उपयोग की जाती है, कभी भी कई संदर्भों से छेड़छाड़ करने का इरादा नहीं था।

मेमोरी मैनेजर, जिसे जब भी आप किसी सरणी (मॉलोक के समतुल्य) के नए सदस्य को सेट करते हैं, एक को अनसेट (मुफ्त के बराबर) सेट करते हैं, या एक अपडेट (फ्री मॉलोक के बराबर) को एक इंटीग्रल हिस्सा है, साझा कुछ भी वास्तुकला, और अन्य चीजों के साथ विशेष रूप से किसी अन्य संदर्भ द्वारा आवंटित मुक्त स्मृति के किसी भी संदर्भ को अस्वीकार करने के लिए डिज़ाइन किया गया है, क्योंकि यह साझा कुछ भी उल्लंघन का उल्लंघन नहीं करता है।

वर्चुअल मशीन मानती है कि यह एक सरणी है जो एक सरणी में हेरफेर कर रहा है।

सभी एक्सटेंशन कोड एक ही धारणा बनाता है।

नियमों को अनदेखा करने के परिणाम - कुछ भी साझा नहीं करें - गंभीर हैं: आप PHP को क्रैश करते हैं।

यह सब आपको कई संदर्भों में वास्तविक सरणी को एक वास्तविक सरणी को स्टोर और हेरफेर करने की इजाजत देता है, और इसे अवांछनीय बनाना चाहिए।

PHP5

सरणी उन्हें एक Threaded वस्तु के सदस्य के रूप स्थापित करने पर धारावाहिक की जाएगी।

आपको Threaded ऑब्जेक्ट्स के साथ अपने सरणी के उपयोग को प्रतिस्थापित करना चाहिए।

ए Threaded ऑब्जेक्ट का उपयोग किया जा सकता है जैसे कि यह एक सरणी थी।

<?php 
class Test extends Thread { 
    public function __construct(Threaded $storage) { 
     $this->storage = $storage; 
    } 

    public function run(){ 
     $i = 0; 
     while(++$i < 10) { 
      $this->storage[]=rand(0,1000); 
     } 

     $this->synchronized(function($thread){ 
      $thread->stored = true; 
      $thread->notify(); 
     }, $this); 
    } 
} 

$storage = new Threaded(); 
$my = new Test($storage); 
$my->start(); 

$my->synchronized(function(Thread $thread){ 
    while (!$thread->stored) { 
     $thread->wait(); 
    } 
}, $my); 

var_dump($storage); 
?> 

PHP7

pthreads v3 (PHP7) Threaded वस्तुओं के लिए स्वत: अचल स्थिति की अवधारणाओं का परिचय:

यहाँ पाने के लिए कुछ आप आरंभ है।

pthreads v3 में अचल स्थिति पर मेरी blog पद से उद्धरण:

pthreads v3 में, एक और Threaded ऑब्जेक्ट में एक Threaded वस्तु के एक सदस्य (एक) की स्थापना (बी) संदर्भ बनाता है कि एबी अपरिवर्तनीय है।

अपरिवर्तनीयता एक प्रदर्शन अनुकूलन है।

स्पष्ट रूप से सरणी के लिए अधिकांश उपयोग मामलों में सरणी को म्यूट करना शामिल है, जो Threaded ऑब्जेक्ट्स अब हमेशा समर्थन करने में सक्षम नहीं हैं।

इस विशेष मामले में, Threaded सरणी के सदस्यों में से कोई भी Threaded नहीं है।

pthreads v3 (PHP7) Volatile ऑब्जेक्ट्स की अवधारणा को प्रस्तुत करता है।

वाष्पशील, विशेषण: विशेष रूप से बदतर के लिए तेजी से और अप्रत्याशित रूप से बदलने के लिए, उत्तरदायी।

Volatile वस्तुओं धीमी गति से Threaded वस्तुओं क्योंकि वे प्रदर्शन अनुकूलन नहीं है जो हमें करने की अनुमति अचल स्थिति से लाभ नहीं कर सकते हैं।

Volatile ऑब्जेक्ट्स pthreads v3 में सरणी के लिए अच्छे विकल्प के रूप में कार्य करते हैं। pthreads Volatile वस्तुओं जब वे Threaded वस्तुओं के सदस्यों के रूप में स्थापित कर रहे हैं करने के लिए सरणियों विवश होगा:

<?php 
class Test extends Thread { 
    public function run(){ 
     $array = [ 
      "Hello", 
      "World" 
     ]; 

     var_dump($array); 

     $this->array = $array; 

     var_dump($this->array); 
    } 
} 

$test = new Test(); 
$test->start() && $test->join(); 
?> 

निकलेगा:

array(2) { 
    [0]=> 
    string(5) "Hello" 
    [1]=> 
    string(5) "World" 
} 
object(Volatile)#2 (2) { 
    [0]=> 
    string(5) "Hello" 
    [1]=> 
    string(5) "World" 
} 

यह Thread की रनटाइम के दौरान अपेक्षा के अनुरूप व्यवहार करने के लिए $this->array कारण बनता है।

वहाँ एक पक्ष प्रभाव है, तो निम्न कोड के उत्पादन के रूप में रेखांकित है:

<?php 
class Test extends Thread { 
    public function __construct(array $array) { 
     $this->array = $array; 
    } 

    public function run(){ 
     var_dump($this->array); 
    } 
} 

$array = [ 
    "Hello", 
    "World" 
]; 
$test = new Test($array); 
$test->start() && $test->join(); 
var_dump($array); 
?> 

निकलेगा:

object(Volatile)#2 (2) { 
    [0]=> 
    string(5) "Hello" 
    [1]=> 
    string(5) "World" 
} 
array(2) { 
    [0]=> 
    string(5) "Hello" 
    [1]=> 
    string(5) "World" 
} 

Thread में Volatile वस्तु array से जुड़ा नहीं है ध्यान दें कि कि इसे इसके निर्माता के लिए आपूर्ति की गई थी, ताकि मुख्य संदर्भ अभी भी array में हेरफेर कर रहा हो।

स्वचालित दबाव WTfs-प्रति-मिनट की दर को कम करने में कार्य करता है जब Thread किसी अन्य स्रोत से पारित एक सरणी का उपयोग करता है।

यह स्पष्ट होना हमेशा बेहतर होता है; जबरन पर भरोसा नहीं करना सबसे अच्छा विकल्प है।

यदि आप पहले से ही जानते हैं कि कुछ निर्भरता सरणी होगी, तो उन्हें पूरी तरह से जबरदस्ती से परहेज करने के लिए सदस्यों के रूप में सेट करने से पहले इससे निपटें।

यह एक स्पष्ट कलाकारों का उपयोग करके Volatile के लिए स्वत: बलात्कार से बचने के लिए संभव है:

<?php 
class Test extends Thread { 
    public function run() { 
     $this->result = (array) [ 
      "Hello" => "World" 
     ]; 
    } 
} 

$test = new Test(); 
$test->start() && $test->join(); 
var_dump($test->result); 
?> 

निकलेगा

array(1) { 
    ["Hello"]=> 
    string(5) "World" 
} 

उदाहरण कोड पता चलता है, यह है जब आप वास्तव में चाहते हैं के लिए उपयोगी है परिणाम स्टोर करने के लिए एक सरणी का उपयोग करने के लिए। PHP5 के साथ, सरणी को भंडारण के लिए क्रमबद्ध किया जाएगा।