PHP并发多进程处理利器Gearman使用介绍,利器gearman_PHP教程
PHP并发多进程处理利器Gearman使用介绍,利器gearman
工作中我们有时候会遇到比如需要同时发布数据到多个个服务器上,或者同时处理多个任务。可以使用PHP的curl_multi的方式并发处理请求,但是由于网络和数据以及各个服务器等等的一些情况导致这种并发处理的响应时间很慢,因为在并发请求的过程中还包括记录日志,处理数据等逻辑,等待处理结果并返回,所以也不能友好的满足后台操作的体验。
现在有另外一种方案,利Gearman来实现并发的需求。通过Client将请求发送到Gearman的Jobs,在每个Work中来再来进行curl_multi和数据处理和日志等一些操作,同时用supervisor 来监控Gearman以及Works的进程,这样可以实现一个并行的多进程和负载均衡的方案。
Gearman可以做什么:
异步处理:图片处理,订单处理,批量邮件/通知之类的
要求高CPU或内存的处理:大容量的数据处理,MapReduce运算,日志聚集,视频编码
分布式和并行的处理
定时处理:增量更新,数据复制
限制速率的FIFO处理
分布式的系统监控任务
Gearman工作原理:
使用Gearman的应用通常有三部分组成:一个Client、一个Worker、一个 任务服务器。 Client的作用是提出一个 Job 任务 交给 Job Server 任务服务器。Job Server 会去寻找一个 合适的 Worker 来完成这项任务。Worker 执行由 Client 发送过来的 Job,并且将结果通过 Job Server 返回给 Client。Gearman 提供了 Client 和 Worker 的 API,利用这些API 应用可以同 Gearman Job Server来进行通信。Gearman 内部 Client 和 Worker 之间的通信都是通过 TCP 连接来进行的。
Gearman可以将工作的负载分担到不同的机器中。
安装:
复制代码 代码如下:
rpm -ivh http://dl.iuscommunity.org/pub/ius/stable/Redhat/6/x86_64/epel-release-6-5.noarch.rpm
yum install -y gearmand
启动:
gearmand -d
安装PHP Gearman扩展
我都是用pcel来安装的,你也可以下载源码包来编译安装,但是记得要先安装libgearman和re2c,不然扩展编译安装会出错。
pecl install gearman #不成功并提示版本问题可以试试 pecl install gearman-1.0.3,默认好像是1.1.2
编译安装也很简单
复制代码 代码如下:
wget -c http://pecl.php.net/get/gearman-1.1.1.tgz
tar zxvf gearman-1.1.1.tgz
phpize
./configure
make && make install
echo "extension=gearman.so" >> /etc/php.ini
PHP接口函数
Gearman提供很多完善的扩展函数,包括GearmanClient,GearmanJob,GearmanTask,GearmanWorker,具体可以查看PHP官方手册.
这是官方提供的Example其中的一个,相当与一个并发的分发任务处理的例子
<?php $client = new GearmanClient(); $client->addServer(); // initialize the results of our 3 "query results" here $userInfo = $friends = $posts = null; // This sets up what gearman will callback to as tasks are returned to us. // The $context helps us know which function is being returned so we can // handle it correctly. $client->setCompleteCallback(function(GearmanTask $task, $context) use (&$userInfo, &$friends, &$posts) { switch ($context) { case 'lookup_user': $userInfo = $task->data(); break; case 'baconate': $friends = $task->data(); break; case 'get_latest_posts_by': $posts = $task->data(); break; } }); // Here we queue up multiple tasks to be execute in *as much* parallelism as gearmand can give us $client->addTask('lookup_user', 'joe@joe.com', 'lookup_user'); $client->addTask('baconate', 'joe@joe.com', 'baconate'); $client->addTask('get_latest_posts_by', 'joe@joe.com', 'get_latest_posts_by'); echo "Fetching...\n"; $start = microtime(true); $client->runTasks(); $totaltime = number_format(microtime(true) - $start, 2); echo "Got user info in: $totaltime seconds:\n"; var_dump($userInfo, $friends, $posts);
gearman_work.php
<?php $worker = new GearmanWorker(); $worker->addServer(); $worker->addFunction('lookup_user', function(GearmanJob $job) { // normally you'd so some very safe type checking and query binding to a database here. // ...and we're gonna fake that. sleep(3); return 'The user requested (' . $job->workload() . ') is 7 feet tall and awesome'; }); $worker->addFunction('baconate', function(GearmanJob $job) { sleep(3); return 'The user (' . $job->workload() . ') is 1 degree away from Kevin Bacon'; }); $worker->addFunction('get_latest_posts_by', function(GearmanJob $job) { sleep(3); return 'The user (' . $job->workload() . ') has no posts, sorry!'; }); while ($worker->work());
我在3个终端中都执行了gearman_work.php
ryan@ryan-lamp:~$ ps aux | grep gearman* | grep -v grep gearman 1504 0.0 0.1 60536 1264 ? Ssl 11:06 0:00 /usr/sbin/gearmand --pid-file=/var/run/gearman/gearmand.pid --user=gearman --daemon --log-file=/var/log/gearman-job-server/gearman.log --listen=127.0.0.1 ryan 2992 0.0 0.8 43340 9036 pts/0 S+ 14:05 0:00 php /var/www/gearmand_work.php ryan 3713 0.0 0.8 43340 9036 pts/1 S+ 14:05 0:00 php /var/www/gearmand_work.php ryan 3715 0.0 0.8 43340 9036 pts/2 S+ 14:05 0:00 php /var/www/gearmand_work.php
来查看下执行gearman_work.php的结果shell
复制代码 代码如下:
Fetching...
Got user info in: 3.03 seconds:
string(59) "The user requested (joe@joe.com) is 7 feet tall and awesome"
string(56) "The user (joe@joe.com) is 1 degree away from Kevin Bacon"
string(43) "The user (joe@joe.com) has no posts, sorry!"
看到上面的3.03 seconds,说明client请求过去的任务被并行分发执行了。
在实际的生产环境中,为了监测gearmand和work的进程没有被意外退出,我们可以借助Supervisor这个工具.

Heiße KI -Werkzeuge

Undresser.AI Undress
KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover
Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Undress AI Tool
Ausziehbilder kostenlos

Clothoff.io
KI-Kleiderentferner

AI Hentai Generator
Erstellen Sie kostenlos Ai Hentai.

Heißer Artikel

Heiße Werkzeuge

Notepad++7.3.1
Einfach zu bedienender und kostenloser Code-Editor

SublimeText3 chinesische Version
Chinesische Version, sehr einfach zu bedienen

Senden Sie Studio 13.0.1
Leistungsstarke integrierte PHP-Entwicklungsumgebung

Dreamweaver CS6
Visuelle Webentwicklungstools

SublimeText3 Mac-Version
Codebearbeitungssoftware auf Gottesniveau (SublimeText3)

Heiße Themen



Als hochgradig gleichzeitige Programmiersprache ermöglichen der integrierte Coroutine-Mechanismus und die Multithread-Operationen von Golang ein leichtes Multitasking. In einem Multiprozess-Verarbeitungsszenario sind jedoch die Kommunikation und der gemeinsame Speicher zwischen verschiedenen Prozessen zu Schlüsselthemen bei der Programmentwicklung geworden. In diesem Artikel wird die Anwendungsmethode zur Realisierung des gemeinsamen Speichers zwischen mehreren Prozessen in Golang vorgestellt. 1. So implementieren Sie Multiprozesse in Golang In Golang kann die gleichzeitige Verarbeitung mehrerer Prozesse auf verschiedene Arten implementiert werden, einschließlich Fork, os.Process,

Jeder weiß, dass Node.js Single-Threading ist, aber er weiß nicht, dass es auch ein Multi-Thread-Modul bietet, um die Verarbeitung einiger spezieller Aufgaben zu beschleunigen. Dieser Artikel führt Sie zum Verständnis des Multi-Threading von Node. js, in der Hoffnung, mehr darüber zu erfahren.

Golang ist ein Multiprozess und sein Thread-Modell ist das MPG-Modell. Insgesamt entsprechen Go-Prozesse und Kernel-Threads vielen-zu-vielen, daher müssen sie zunächst multithreaded sein. Golang verfügt über ein sogenanntes M-Verhältnis-N-Modell, mit dem N-Threads erstellt werden können. Im Allgemeinen ist N viel größer als M. Es handelt sich jedoch im Wesentlichen um ein Multithread-Modell Es wird betont, dass Entwickler Kanäle für die Synchronisierung zwischen Coroutinen verwenden sollten.

Sperren und Synchronisierung bei der gleichzeitigen Programmierung Bei der gleichzeitigen Programmierung werden mehrere Prozesse oder Threads gleichzeitig ausgeführt, was zu Ressourcenkonflikten und Inkonsistenzproblemen führen kann. Um diese Probleme zu lösen, sind Sperren und Synchronisationsmechanismen erforderlich, um den Zugriff auf gemeinsam genutzte Ressourcen zu koordinieren. Konzept der Sperre Eine Sperre ist ein Mechanismus, der jeweils nur einem Thread oder Prozess den Zugriff auf eine gemeinsam genutzte Ressource ermöglicht. Wenn ein Thread oder Prozess eine Sperre erhält, wird der Zugriff anderer Threads oder Prozesse auf die Ressource blockiert, bis die Sperre aufgehoben wird. Arten von Sperren Es gibt verschiedene Arten von Sperren in Python: Mutex-Sperre (Mutex): stellt sicher, dass jeweils nur ein Thread oder Prozess auf Ressourcen zugreifen kann. Bedingungsvariable: Ermöglicht einem Thread oder Prozess, auf eine bestimmte Bedingung zu warten und dann die Sperre zu erhalten. Lese-/Schreibsperre: Ermöglicht mehreren Threads das gleichzeitige Lesen von Ressourcen, erlaubt jedoch nur einem Thread das Schreiben von Ressourcen

PHP-Entwicklungsfähigkeiten: So verwenden Sie geplante Gearman-Aufgaben zur Verarbeitung der MySQL-Datenbank. Einführung: Gearman ist ein verteiltes Open-Source-Aufgabenplanungssystem, mit dem Aufgaben parallel ausgeführt und die Verarbeitungsfähigkeiten des Systems verbessert werden können. In der PHP-Entwicklung verwenden wir Gearman häufig, um zeitaufwändige oder asynchrone Aufgaben zu erledigen. In diesem Artikel wird erläutert, wie Sie mit Gearman geplante Aufgaben zur Abwicklung von MySQL-Datenbankvorgängen implementieren. 1. Installieren Sie Gearman im Linux-System

Dieser Artikel vermittelt Ihnen relevantes Wissen über PHP. Hier finden Sie eine Zusammenfassung einiger Probleme der Multiprozessentwicklung mit Antworten Seien Sie hilfreich für alle.

Wie implementiert man Multiprozesse im Knoten? Wie stelle ich ein Knotenprojekt bereit? Der folgende Artikel wird Ihnen dabei helfen, sich die relevanten Kenntnisse des Multiprozessmodells und der Projektbereitstellung von Node.j anzueignen. Ich hoffe, er wird Ihnen hilfreich sein!

Mit der Verbesserung der Computerleistung und der Beliebtheit von Mehrkernprozessoren ist die Mehrprozessprogrammierung nach und nach zu einem unverzichtbaren Bestandteil des modernen Programmierbereichs geworden. In der Go-Sprache ist auch die Multiprozessprogrammierung sehr einfach zu implementieren. In diesem Artikel wird die Verwendung von Multiprozessen in Go vorgestellt. 1. Goroutinen In der Go-Sprache kann gleichzeitige Programmierung durch Goroutinen erreicht werden. „Goroutine“ kann als „leichter Thread“ in der Go-Sprache angesehen werden. Goroutinen werden von der Go-Laufzeit geplant und
