Les objets de fil de pthread réinitialisent leur état

Votre problème est que vous accédez à la variable du fil principal et du fil mythead. La CPU met en cache la variable et elle est mise à jour dans le cache pour mythread mais pas dans le cache pour le fil principal, de sorte que vos deux threads ne voient jamais les autres changements de fil. En Java / C, etc. Il y a le mot clé volatil mais je ne sais pas si cela existe en PHP.

Je pense que vous devriez essayer d'appeler les méthodes en somme synchronisée ( http: // php .NET / Manual / fr / thread.Synchronized.php ) p>

Par exemple, au lieu de: P>

        $this->synchronized(function($thread){
            $thread->sum->add(5);
        }, $this);

Tout objet non descendu d'une définition de Pthreads sera sérialisé lors de la définition d'un membre d'un objet issu de Pthreads.

Opérations telles que + = et [] Utilisez des pointeurs en interne, la sérialisation est incompatible avec des pointeurs pour d'autres objets. Dans le manuel de la page Introduction, il stipule que tout objet destiné à être manipulé par plusieurs contextes devrait s'étendre sur l'empilable, le thread ou le travailleur, comme P> xxx pré>

si la somme n'était pas utilisée Pointeurs Vous auriez la possibilité de récupérer la référence de l'objet fileté après une jointure. p>

Ce sont des opérations simples, vous n'êtes pas obligé de synchroniser. La seule fois que vous devriez synchroniser, c'est lorsque vous envisagez d'attendre sur un objet ou de notifier une. P>

Les objets groupés avec Pthreads sont très plus adaptés à cet environnement et ne sont jamais sérialisés. P>

Veuillez lire l'intro dans le manuel et tous les exemples des méthodes que vous souhaitez utiliser pour déterminer exactement ce que c'est quoi, puis n'hésitez pas à demander pourquoi :) p>

Je sais que les utilisateurs de PHP AREN Il avait l'habitude de devoir faire des recherches, mais nous repoussons l'enveloppe ici, vous trouverez que vous trouverez des moyens corrects de faire les choses de manière incorrecte, la plupart d'entre elles sont documentées dans des exemples et tout ce qui n'est pas sûr que je ne suis sûr pas être extraite de moi dessus et finalement, trouvez-moi que c'est la voie à la documentation. P>

Je ne sais pas si l'exemple que vous avez donné était de tester des objets en particulier, mais le code que vous avez fourni n'est pas nécessaire de ne pas être deux objets et de ne pas avoir besoin de Il s'agit de deux objets, considérez les éléments suivants: p> xxx pré>

Il peut être utile de voir quelques fonctionnalités supplémentaires en action avec une explication, donc Voici, voici un exemple similaire à vous: P>

<?php
class MyThread extends Thread {
    public $sum;

    public function __construct() {
        $this->sum = 0;
    }

    public function run(){
        for ($i=0; $i < 10; $i++) {
            $this->add(5);

            $this->writeOut("[%d]: %d\n", $i, $this->sum);
        }

        $this->synchronized(function($thread){
            $thread->writeOut("Sending notification to Process from %s #%lu ...\n", __CLASS__, $thread->getThreadId());
            $thread->notify();
        }, $this);
    }

    public function add($num) { $this->sum += $num; }
    public function getValue() { return $this->sum; }

    /* when two threads attempt to write standard output the output will be jumbled */
    /* this is a good use of protecting a method so that 
        only one context can write stdout and you can make sense of the output */
    protected function writeOut($format, $args = null) {
        $args = func_get_args();
        if ($args) {
            vprintf(array_shift($args), $args);
        }
    }
}

$thread = new MyThread();
$thread->start();

/* so this is synchronization, rather than joining, which requires an actual join of the underlying thread */
/* you can wait for notification that the thread is done what you started it to do */
/* in these simple tests the time difference may not be apparent, but in real complex objects from */
/* contexts populated with more than 1 object having executed many instructions the difference may become very real */
$thread->synchronized(function($thread){
    if ($thread->getValue()!=50) {
        $thread->writeOut("Waiting for thread ...\n");
        /* you should only ever wait _for_ something */
        $thread->wait();
        $thread->writeOut("Process recieved notification from Thread ...\n");
    }
}, $thread);

var_dump($thread->getValue());
?>

Je pensais que je fais quelque chose de mal aussi. Comme mentionné [] et d'autres opérations utilisant des pointeurs ne fonctionneront pas. Ceci est la solution de contournement: xxx

Ceci fonctionne comme nous utilisons [] opération sur une variable de fonction temporaire et que nous la définissons comme une variable de classe.

meilleur exemple pourquoi Il est nécessaire: xxx

afin que nous puissions utiliser et ajouter de nouveaux éléments à la variable dans plusieurs fonctions. La même chose fonctionnera pour + = et d'autres opérateurs, mais vous avez besoin de la variable temporaire pour cela.

Fonction facile à prolonger pour cette option: xxx

eval pourrait travailler ici mais je trouve cela beaucoup plus sûr.