PHP communique avec Golang-tutoriel php-php.cn

Une scène que j'ai rencontrée récemment : phpUne fonction tierce (segmentation des mots balbutiants) doit être utilisée dans le projet, et il se trouve qu'il y a une bibliothèque de classes écrite en Golang sur github Alors la question se pose, comment réaliser la communication entre différentes langues. . Qu'en est-il ?

Solution conventionnelle :

Écrivez un service http/TCP en Golang, et php communique avec Golang via http/TCP
Golang est encapsulé sous forme d'extension php
PHP appelle le fichier exécutable Golang via les commandes système

Problèmes existants :

Requêtes http, les E/S réseau prendront beaucoup de temps
Beaucoup de code doit être encapsulé
Chaque fois que PHP appelle un programme Golang, il doit être initialisé, ce qui prend beaucoup de temps

Objectifs d'optimisation :

Le programme Golang n'est initialisé qu'une seule fois (car l'initialisation prend du temps)
Toutes les requêtes n'ont pas besoin de passer par le réseau
Essayez de ne pas trop modifier le code

Solution :

Package Golang simple, compilez la bibliothèque de classes tierce dans un exécutable fichier
PHP et Golang communiquent via des tuyaux bidirectionnels

Avantages de l'utilisation de la communication par canal bidirectionnel :

1 : encapsulation minimale de la bibliothèque de classes Golang originale est requise
2 : Meilleures performances (la communication IPC est le meilleur moyen de communiquer entre les processus)
3 : Aucune requête réseau n'est requise, ce qui permet de gagner beaucoup de temps
4 : Le programme ne doit être initialisé qu'une seule fois et reste en mémoire

Étapes spécifiques de mise en œuvre :

1 : Démo d'appel originale dans la bibliothèque de classe

      package main
      import (
          "fmt"
          "github.com/yanyiwu/gojieba"
          "strings"
      )

      func main() {
          x := gojieba.NewJieba()
          defer x.Free()

          s := "小明硕士毕业于中国科学院计算所，后在日本京都大学深造"
          words := x.CutForSearch(s, true)
          fmt.Println(strings.Join(words, "/"))
      }

Copier après la connexion

Enregistrez le fichier sous main.go , vous pouvez exécuter

2 : Le code ajusté est :

      package main
      import (
          "bufio"
          "fmt"
          "github.com/yanyiwu/gojieba"
          "io"
          "os"
          "strings"
      )

      func main() {

          x := gojieba.NewJieba(
              "/data/tmp/jiebaDict/jieba.dict.utf8", 
              "/data/tmp/jiebaDict/hmm_model.utf8", 
              "/data/tmp/jiebaDict/user.dict.utf8"
          )
          defer x.Free()

          inputReader := bufio.NewReader(os.Stdin)
          for {
              s, err := inputReader.ReadString('\n')
              if err != nil && err == io.EOF {
                  break
              }
              s = strings.TrimSpace(s)

              if s != "" {
                  words := x.CutForSearch(s, true)
                  fmt.Println(strings.Join(words, " "))
              } else {
                  fmt.Println("get empty \n")
              }
          }
      }

Copier après la connexion

Cela ne prend qu'un quelques ajustements simples à réaliser : à partir de l'entrée standard Recevez

chaîne , puis sortie
après la segmentation des mots Test :

  # go build test
  # ./test
  # //等待用户输入，输入”这是一个测试“
  # 这是 一个 测试 //程序

Copier après la connexion

Sortie normale, indiquant que cat peut interagir avec Golang normalement
```
  //准备一个title.txt，每行是一句文本
  # cat title.txt | ./test
```
Copier après la connexion
Chat illustré ci-dessus Pour communiquer avec Golang, un tuyau unidirectionnel est utilisé. Autrement dit : les données ne peuvent être transmises que de cat à Golang. Les données sorties par Golang ne sont pas renvoyées à cat, mais sont directement affichées à l'écran. Mais l'exigence de l'article est la suivante : php communique avec Golang. Autrement dit, php doit transmettre les données à Golang, et Golang doit également renvoyer les résultats d'exécution à php. Un pipeline bidirectionnel doit donc être mis en place.
L'utilisation des pipes en PHP :
, je n'entrerai pas dans les détails car cette méthode ne peut pas résoudre le problème de l'article. popen("/path/test") Pipeline bidirectionnel :
```
      $descriptorspec = array( 
          0 => array("pipe", "r"), 
            1 => array("pipe", "w")
      );
      $handle = proc_open(
          '/webroot/go/src/test/test', 
          $descriptorspec, 
          $pipes
      );
      fwrite($pipes['0'], "这是一个测试文本\n");
      echo fgets($pipes[1]);
```
Copier après la connexion
Explication : Utilisez proc_open pour ouvrir un processus et appeler le programme Golang. Dans le même temps, un pipeline bidirectionnel pipes
array est renvoyé. PHP écrit les données dans $pipe['0'] et lit les données dans $pipe['1'].

Laissez n'importe quelle langue communiquer via un canal bidirectionnel.

(Toutes les langues implémenteront le contenu lié au pipeline) Test :

Grâce au

test de comparaison

, calculez le temps pris par chaque processus. Le fichier title.txt mentionné ci-dessous contient 1 million de lignes de texte. Chaque ligne de texte est le titre du produit extrait de la plateforme b2b1 : Le processus global prend du temps

<a. href="http%20://m.sbmmt.com/wiki/1268.html" target="_blank">time<p> cat title.txt ./test > /www.php .cn/wiki/62.html" target="_blank">null<br></p></a.>

<a href="//m.sbmmt.com/wiki/1268.html" target="_blank">time</a> cat title.txt | ./test > /dev/<a href="//m.sbmmt.com/wiki/62.html" target="_blank">null</a>

Prend du temps : 14,819 secondes, dont :

Le processus cat lit le texte

Transmettre les données à Golang via le tuyau

Golang traite les données et renvoie le résultat à l'écran

2 : Il faut du temps pour calculer la fonction de segmentation de mots

. Solution : Supprimez l'appel de la fonction de segmentation de mots, c'est-à-dire : Commentaire et supprimez la ligne de code qui appelle la segmentation de mots dans le code source de Golang
time cat title.txt | ./test > /dev/null

Prend du temps : 1,817 secondes, le temps consommé comprend :

le processus cat lit le texte

transfère les données vers Golang via un pipeline

Golang traite les données et renvoie le résultat à l'écran

分词耗时 = (第一步耗时) - (以上命令所耗时)
分词耗时 : 14.819 - 1.817 = 13.002秒

3：测试cat进程与Golang进程之间通信所占时间
time cat title.txt > /dev/null

耗时：0.015秒，消耗时间包含：

进程cat读出文本

通过管道将数据传入Golang

go处理数据，将结果返回到屏幕

管道通信耗时：（第二步耗时） - （第三步耗时）
管道通信耗时： 1.817 - 0.015 = 1.802秒

4：PHP与Golang通信的时间消耗
编写简单的php文件：

        <?php
            $descriptorspec = array( 
                0 => array("pipe", "r"), 
                1 => array("pipe", "w")
            );

            $handle = proc_open(
                '/webroot/go/src/test/test', 
                $descriptorspec, 
                $pipes
            );

            $fp = fopen("title.txt", "rb");

            while (!feof($fp)) {
                fwrite($pipes['0'], trim(fgets($fp))."\n");
                echo fgets($pipes[1]);
            }

            fclose($pipes['0']);
            fclose($pipes['1']);
            proc_close($handle);

Copier après la connexion

流程与上面基本一致，读出title.txt内容，通过双向管道传入Golang进程分词后，再返回给php （比上面的测试多一步：数据再通过管道返回）
time php popen.php > /dev/null

耗时：24.037秒，消耗时间包含：

进程PHP读出文本

通过管道将数据传入Golang

Golang处理数据

Golang将返回结果再写入管道，PHP通过管道接收数据

将结果返回到屏幕

结论：

1 ：整个分词过程中的耗时分布

使用cat控制逻辑耗时：        14.819 秒
使用PHP控制逻辑耗时:         24.037 秒（比cat多一次管道通信）
单向管道通信耗时：           1.8    秒
Golang中的分词函数耗时：     13.002 秒

Copier après la connexion

2：分词函数的性能： 单进程，100万商品标题分词，耗时13秒
以上时间只包括分词时间，不包括词典载入时间。但在本方案中，词典只载入一次，所以载入词典时间可以忽略（1秒左右）

3：PHP比cat慢 (这结论有点多余了，呵呵）
语言层面慢: (24.037 - 1.8 - 14.819) / 14.819 = 50%
单进程对比测试的话，应该不会有哪个语言比cat更快。

PHP communique avec Golang

Solution conventionnelle :

Problèmes existants :

Objectifs d'optimisation :

Solution :

Avantages de l'utilisation de la communication par canal bidirectionnel :

Étapes spécifiques de mise en œuvre :

Grâce au

结论：

相关问题：