Introduction

PHP a plein Multi-Threading support dont vous pouvez tirer pleinement avantage de tant de façons. Ont été en mesure de démontrer cette capacité multi-Threading dans différents exemples:

• Comment peut-on utiliser le multi threading dans les applications PHP
• pcntl exécute le même code plusieurs fois, assistance requise
• amélioration de L'efficacité des racleurs HTML avec pcntl_fork ()

Un Recherche rapide serait de donner des ressources supplémentaires.

catégories

1: requêtes MySQL

MySQL est entièrement multi-threadé et fera usage de plusieurs CPU, à condition que le système d'exploitation les supporte, il serait également maximiser les ressources du système s'il est correctement configuré pour le rendement.

un réglage typique dans le my.ini qui affecte la performance du fil est:

thread_cache_size = 8

thread_cache_size peut être augmenté afin d'améliorer les performances si vous avez beaucoup de nouvelles connexions. Normalement, cela ne fournit pas une amélioration notable de la performance si vous avez une bonne implémentation du thread. Toutefois, si votre serveur voit des centaines de connexions par seconde vous devriez normalement définir thread_cache_size suffisamment haut de sorte que la plupart des nouvelles connexions utilisent des threads en cache

si vous utilisez Solaris alors vous pouvez utiliser

thread_concurrency = 8 

thread_concurrency permet aux applications de donner au système de threads un indice sur le nombre désiré de threads qui doivent être exécutés en même temps.

cette variable est obsolète à partir de MySQL 5.6.1 et est supprimé dans MySQL 5.7. Vous devriez supprimer cela des fichiers de configuration MySQL chaque fois que vous le voyez à moins qu'ils ne soient Pour Solaris 8 ou plus tôt.

InnoDB: :

vous n'avez pas de telles limitations si vous utilisez Innodb a le moteur de stockage parce qu'il prend en charge la pleine concurrence de thread

innodb_thread_concurrency //  Recommended 2 * CPUs + number of disks

, Vous pouvez aussi regarder innodb_read_io_threads et innodb_write_io_threads où la valeur par défaut est 4 et il peut être augmenté à 64 en fonction du matériel

autres:

les autres configurations à prendre en compte sont: key_buffer_size , table_open_cache , sort_buffer_size etc. qui se traduisent par de meilleures performances

PHP:

Dans pure PHP vous peut créer un Worker MySQL où chaque requête est exécutée dans des threads PHP séparés

$sql = new SQLWorker($host, $user, $pass, $db);
$sql->start();

$sql->stack($q1 = new SQLQuery("One long Query")); 
$sql->stack($q2 = new SQLQuery("Another long Query"));

$q1->wait(); 
$q2->wait(); 

// Do Something Useful

voici un exemple complet de travail de SQLWorker

2: Analyse de contenu HTML

I suspect that a great deal of computation time is spent in this task.

si vous connaissez déjà le problème , alors il est plus facile de le résoudre via des boucles d'événements, des files d'attente de travail ou en utilisant des Threads.

Travailler sur un document, un à un le temps peut être un very very slow painful process . @ka une fois piraté son chemin en utilisant ajax à l'appel à la demande multiple, certains esprits créatifs serait juste bifurquer le processus en utilisant pcntl_fork mais si vous utilisez windows alors vous ne pouvez pas profiter de pcntl

avec pThreads supportant les systèmes windows et Unix, vous n'avez pas une telle limitation. Est aussi simple que .. Si vous devez analyser 100 document ? Spawn 100 Threads ... Simple

la Numérisation HTML

// Scan my System
$dir = new RecursiveDirectoryIterator($dir, RecursiveDirectoryIterator::SKIP_DOTS);
$dir = new RecursiveIteratorIterator($dir);

// Allowed Extension
$ext = array(
        "html",
        "htm"
);

// Threads Array
$ts = array();

// Simple Storage
$s = new Sink();

// Start Timer
$time = microtime(true);

$count = 0;
// Parse All HTML
foreach($dir as $html) {
    if ($html->isFile() && in_array($html->getExtension(), $ext)) {
        $count ++;
        $ts[] = new LinkParser("$html", $s);
    }
}

// Wait for all Threads to finish
foreach($ts as $t) {
    $t->join();
}

// Put The Output
printf("Total Files:\t\t%s \n", number_format($count, 0));
printf("Total Links:\t\t%s \n", number_format($t = count($s), 0));
printf("Finished:\t\t%0.4f sec \n", $tm = microtime(true) - $time);
printf("AvgSpeed:\t\t%0.4f sec per file\n", $tm / $t);
printf("File P/S:\t\t%d file per sec\n", $count / $tm);
printf("Link P/S:\t\t%d links per sec\n", $t / $tm);

Sortie

Total Files:            8,714
Total Links:            105,109
Finished:               108.3460 sec
AvgSpeed:               0.0010 sec per file
File P/S:               80 file per sec
Link P/S:               907 links per sec

Classe Utilisée

Sink

class Sink extends Stackable {
    public function run() {
    }
}

LinkParser

class LinkParser extends Thread {

    public function __construct($file, $sink) {
        $this->file = $file;
        $this->sink = $sink;
        $this->start();
    }

    public function run() {
        $dom = new DOMDocument();
        @$dom->loadHTML(file_get_contents($this->file));
        foreach($dom->getElementsByTagName('a') as $links) {
            $this->sink[] = $links->getAttribute('href');
        }
    }
}

expérience

en Essayant d'analyse 8,714 les fichiers qui ont des liens 105,109 sans threads et voir combien de temps cela prendrait.

Meilleure Architecture

la fraie trop de fils qui n'est pas une chose intelligente à faire dans la production. Une meilleure approche serait d'utiliser Pooling . Avoir une réserve de définir travailleurs puis cheminée avec un Task

Amélioration De La Performance

amende l'exemple ci-dessus est toujours improved . Insted de l'attente pour le système de scanner all files in a single thread vous pouvez ainsi use multiple threads scan my system pour les fichiers puis empiler les données aux travailleurs pour le traitement

3: mise à jour de L'index de recherche

la première réponse a répondu à cette question, mais il y a tellement de façons d'améliorer le rendement. Avez-vous déjà envisagé Approche fondée sur les événements ?

Présentation De L'Événement

@rdlowrey citation 1:

pensez-y comme ça. Imaginez que vous devez servir 10.000 clients connectés simultanément dans votre application web. Traditionnel thread-per-request ou process-per-request les serveurs ne sont pas une option parce que peu importe la légèreté de vos threads tu ne peux toujours pas en garder 10 000 ouverts à la fois.

@rdlowrey citation 2:

d'un autre côté, si vous gardez toutes les sockets dans un processus unique et écoutez pour que ces sockets deviennent lisibles ou inscriptibles, vous pouvez mettre votre serveur entier dans une boucle d'événement unique et opérer sur chaque socket seulement quand il y a quelque chose à lire/écrire.

Pourquoi ne pas expérimenter avec event-driven , non-blocking I/O approche de votre problème. PHP a libevent pour suralimenter votre application.

je sais que cette question est tout Multi-Threading mais si vous avez du temps, vous pouvez regarder ce réacteur nucléaire écrit en PHP par @igorw

enfin

considération

I pensez que vous devriez condenser en utilisant Cache et Job Queue pour une partie de votre tâche. Vous pouvez facilement avoir un message disant

Document uploaded for processing ..... 5% - Done   

alors faire tout le temps de perdre la tâche dans l'arrière-plan. Veuillez consulter pour une étude de cas similaire.

Profilling

Outil De Profilage ?? Il n'y a pas d'outil de profil unique pour une application web de Xdebug à Yslow sont tous très utiles. Par exemple. Xdebug n'a pas d'utilité quand il s'agit de threads parce que son pas pris en charge

Je n'ai pas de favori

la mise à L'échelle des serveurs Web ne va pas faire bouger MySQL d'un pouce quand il s'agit d'accéder aux CPU multicores. Pourquoi? Tout d'abord considérer les deux principaux moteurs de stockage de MySQL

MyISAM

ce moteur de stockage n'a pas accès à plusieurs noyaux. Il n'a jamais et ne sera jamais. Il assure le verrouillage complet de la table pour chaque insertion, mise à jour et suppression. Envoyer des requêtes à partir de plusieurs serveurs Web pour faire quoi que ce soit avec un MyISAM obtient juste un goulot d'étranglement.

InnoDB

avant MySQL 5.1.38, ce moteur de stockage n'a accédé qu'à un seul CPU. Vous avez dû faire des choses étranges comme exécuter MySQL plusieurs fois sur une machine pour forcer les cœurs pour gérer les différentes instances de MySQL . Ensuite, la charge de connexions DB des serveurs Web doit être équilibrée entre les multiples instances. C'est de la vieille école (surtout si vous utilisez des versions de MySQL avant MySQl 5.1.38).

à partir de MySQL 5.1.38, vous installez le nouveau Plugin InnoDB. Il a des fonctionnalités que vous devez régler pour obtenir InnoDB pour accéder à plusieurs CPU. J'ai écrit à ce sujet dans le DBA StackExchange

• Sep 20, 2011 : multi core and MySQL Performance
• Sep 12, 2011 : possible de faire MySQL utiliser plus d'un noyau?
• May 26, 2011 : à propos de la performance des bases de données filetées versus multithreaded

ces nouvelles fonctionnalités sont entièrement disponibles dans MySQL 5.5/5.6 et Percona Server ainsi.

CAVEAT

si votre CMS personnalisé utilise l'indexation/la recherche en texte intégral, vous devriez passer à MySQL 5.6 parce que InnoDB prend maintenant en charge l'indexation/la recherche en texte intégral.

installation à MySQL 5.6 ne va pas automatiquement la Cpu. Vous devrez l'accorder car, si vous ne le faites pas, il est possible que les versions plus anciennes de MySQL soient plus rapides que les versions plus récentes:

• Nov 24, 2011 : pourquoi mysql 5.5 plus lent que 5.1 (linux, en utilisant mysqlslap)
• Oct 05, 2011 : Query fonctionne longtemps dans certaines versions plus récentes de MySQL
• Jun 19, 2011 : Comment puis-je effectuer correctement une base de données MySQL bake-off?

ce n'est peut-être pas une réponse à la question que vous cherchez, mais la solution que vous cherchez traite du filetage. Le Threading est nécessaire pour la programmation multicore, et le threading est et non implémenté en PHP.

mais, dans un sens, vous pourriez simuler un threading en PHP en comptant sur les capacités multitâches du système d'exploitation. Je suggère donné un aperçu rapide de stratégies multi-threading en PHP à élaborer une stratégie pour atteindre ce dont vous avez besoin.

lien mort: Multi-threading strategies in PHP