V2EX = way to explore
V2EX 是一个关于分享和探索的地方
现在注册
已注册用户请  登录
GeekHub
onanying
V2EX  ›  PHP

PHP7.3+Swoole4.4 / Go1.13 / MixPHP2.2 / Beego1.12 性能对比

  •  2
     
  •   onanying · 58 天前 · 3516 次点击
    这是一个创建于 58 天前的主题,其中的信息可能已经有所发展或是发生改变。

    好几年没有做过性能对比了,因为越来越觉得性能并没有那么的重要(相对于生态),今天有时间简单测试一下,因为 Mix v2.1 开始就全部切换为单进程协程模式,因此本次主要测试的是 Co\Http\Server ,测试结果在最后面。

    环境

    • CPU: Intel(R) Core(TM) i7-8700 CPU @ 3.20GHz
    • CPU(s): 12
    • Mem: 15G
    • Linux version 3.10.0-957.10.1.el7.x86_64

    PHP 7.3.12 + Swoole 4.4.14

    代码中使用的单进程 Co\Http\Server ,因此需要利用端口复用 (需要 Linux >= 3.10),开启 12 个进程

    • 代码
    <?php 
    
    \Swoole\Process::daemon();
    
    $scheduler = new \Swoole\Coroutine\Scheduler;
    $scheduler->set([
        'hook_flags' => SWOOLE_HOOK_ALL,
    ]);
    $scheduler->add(function () {
    
    	$server = new \Swoole\Coroutine\Http\Server('0.0.0.0', 8888, false, true);
    	$server->handle('/', function($request, $response){
    		$response->end('hello, world!');
    	});
    	$server->start();
    
    });
    $scheduler->start();
    
    • 开启的进程
    [[email protected]]$ ps -ef | grep test.php
    nobody    1917     1  0 20:22 ?        00:00:02 /usr/local/php-7.3.12/bin/php test.php
    nobody    1923     1  0 20:22 ?        00:00:02 /usr/local/php-7.3.12/bin/php test.php
    nobody    1929     1  0 20:22 ?        00:00:02 /usr/local/php-7.3.12/bin/php test.php
    nobody    1934     1  0 20:22 ?        00:00:02 /usr/local/php-7.3.12/bin/php test.php
    nobody    2154     1  0 20:22 ?        00:00:02 /usr/local/php-7.3.12/bin/php test.php
    nobody    2166     1  0 20:22 ?        00:00:02 /usr/local/php-7.3.12/bin/php test.php
    nobody    2173     1  0 20:22 ?        00:00:02 /usr/local/php-7.3.12/bin/php test.php
    nobody    2181     1  0 20:22 ?        00:00:02 /usr/local/php-7.3.12/bin/php test.php
    nobody    2187     1  0 20:22 ?        00:00:02 /usr/local/php-7.3.12/bin/php test.php
    nobody    2194     1  0 20:22 ?        00:00:02 /usr/local/php-7.3.12/bin/php test.php
    nobody    2200     1  0 20:22 ?        00:00:02 /usr/local/php-7.3.12/bin/php test.php
    nobody    2205     1  0 20:22 ?        00:00:02 /usr/local/php-7.3.12/bin/php test.php
    
    • 测试:多跑几次,基本稳定在 127441.95 左右。
    [[email protected]~]$ ab -n 100000 -c 1000 -k http://127.0.0.1:8888/
    This is ApacheBench, Version 2.3 <$Revision: 1430300 $>
    Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
    Licensed to The Apache Software Foundation, http://www.apache.org/
    
    Benchmarking 127.0.0.1 (be patient)
    
    Server Software:        swoole-http-server
    Server Hostname:        127.0.0.1
    Server Port:            8888
    
    Document Path:          /
    Document Length:        13 bytes
    
    Concurrency Level:      1000
    Time taken for tests:   0.785 seconds
    Complete requests:      100000
    Failed requests:        0
    Write errors:           0
    Keep-Alive requests:    100000
    Total transferred:      16600000 bytes
    HTML transferred:       1300000 bytes
    Requests per second:    127441.95 [#/sec] (mean)
    Time per request:       7.847 [ms] (mean)
    Time per request:       0.008 [ms] (mean, across all concurrent requests)
    Transfer rate:          20659.53 [Kbytes/sec] received
    
    Connection Times (ms)
                  min  mean[+/-sd] median   max
    Connect:        0    0   2.4      0      47
    Processing:     2    7   0.5      7      47
    Waiting:        0    7   0.4      7      14
    Total:          2    8   2.6      7      58
    
    Percentage of the requests served within a certain time (ms)
    

    Go 1.13.4

    Golang 默认使用全部 CPU 线程,因此只需开启一个进程即可。

    • 代码
    package main
    
    import (
        "fmt"
        "net/http"
    )
    
    func main() {
    
        http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
            writer.Write([]byte("hello, world!"))
        })
        err := http.ListenAndServe(":9999", nil)
        if err != nil{
            fmt.Println(err)
        }
    
    }
    
    • 开启的进程
    [[email protected]~]$ ps -ef | grep gotest
    nobody    4409  1859  0 20:25 pts/31   00:00:06 ./gotest_linux
    
    • 测试:多跑几次,基本稳定在 121575.23 左右,比 Swoole 稍微差点,但非常接近,PHP 是动态语言借助 Swoole 做到这个性能确实是非常夸张了。
    [[email protected]~]$ ab -n 100000 -c 1000 -k http://127.0.0.1:9999/
    This is ApacheBench, Version 2.3 <$Revision: 1430300 $>
    Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
    Licensed to The Apache Software Foundation, http://www.apache.org/
    
    Benchmarking 127.0.0.1 (be patient)
    
    Server Software:
    Server Hostname:        127.0.0.1
    Server Port:            9999
    
    Document Path:          /
    Document Length:        13 bytes
    
    Concurrency Level:      1000
    Time taken for tests:   0.823 seconds
    Complete requests:      100000
    Failed requests:        0
    Write errors:           0
    Keep-Alive requests:    100000
    Total transferred:      15400000 bytes
    HTML transferred:       1300000 bytes
    Requests per second:    121575.23 [#/sec] (mean)
    Time per request:       8.225 [ms] (mean)
    Time per request:       0.008 [ms] (mean, across all concurrent requests)
    Transfer rate:          18283.77 [Kbytes/sec] received
    
    Connection Times (ms)
                  min  mean[+/-sd] median   max
    Connect:        0    0   2.4      0      46
    Processing:     2    8   1.1      7      46
    Waiting:        0    8   1.1      7      30
    Total:          2    8   2.7      7      56
    
    Percentage of the requests served within a certain time (ms)
    

    MixPHP V2.2

    接下来我们看一下跑在 PHP7.3 + Swoole4.4 下的 Mix V2.2 能跑多少。

    • 开启的进程
    [[email protected]]$ ps -ef | grep mix.php
    nobody   24783     1  0 20:51 ?        00:00:00 /usr/local/php-7.3.12/bin/php mix/bin/mix.php web -r -d
    nobody   24801     1  0 20:51 ?        00:00:00 /usr/local/php-7.3.12/bin/php mix/bin/mix.php web -r -d
    nobody   24821     1  0 20:51 ?        00:00:00 /usr/local/php-7.3.12/bin/php mix/bin/mix.php web -r -d
    nobody   24839     1  0 20:51 ?        00:00:00 /usr/local/php-7.3.12/bin/php mix/bin/mix.php web -r -d
    nobody   24856     1  0 20:51 ?        00:00:00 /usr/local/php-7.3.12/bin/php mix/bin/mix.php web -r -d
    nobody   24873     1  0 20:51 ?        00:00:00 /usr/local/php-7.3.12/bin/php mix/bin/mix.php web -r -d
    nobody   24891     1  0 20:51 ?        00:00:00 /usr/local/php-7.3.12/bin/php mix/bin/mix.php web -r -d
    nobody   24908     1  0 20:51 ?        00:00:00 /usr/local/php-7.3.12/bin/php mix/bin/mix.php web -r -d
    nobody   24927     1  0 20:51 ?        00:00:00 /usr/local/php-7.3.12/bin/php mix/bin/mix.php web -r -d
    nobody   24946     1  0 20:51 ?        00:00:00 /usr/local/php-7.3.12/bin/php mix/bin/mix.php web -r -d
    nobody   24963     1  0 20:51 ?        00:00:00 /usr/local/php-7.3.12/bin/php mix/bin/mix.php web -r -d
    nobody   24981     1  0 20:51 ?        00:00:00 /usr/local/php-7.3.12/bin/php mix/bin/mix.php web -r -d
    
    • 测试:多跑几次,基本稳定在 110050.47 左右,比原生 Swoole 降低了 13.6%,整个框架的代码只降低了这个比例,还是蛮可以的。
    [[email protected]~]$ ab -n 100000 -c 1000 -k http://127.0.0.1:9501/
    This is ApacheBench, Version 2.3 <$Revision: 1430300 $>
    Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
    Licensed to The Apache Software Foundation, http://www.apache.org/
    
    Benchmarking 127.0.0.1 (be patient)
    
    Server Software:        swoole-http-server
    Server Hostname:        127.0.0.1
    Server Port:            9501
    
    Document Path:          /
    Document Length:        13 bytes
    
    Concurrency Level:      1000
    Time taken for tests:   0.909 seconds
    Complete requests:      100000
    Failed requests:        0
    Write errors:           0
    Keep-Alive requests:    100000
    Total transferred:      18100000 bytes
    HTML transferred:       1300000 bytes
    Requests per second:    110050.47 [#/sec] (mean)
    Time per request:       9.087 [ms] (mean)
    Time per request:       0.009 [ms] (mean, across all concurrent requests)
    Transfer rate:          19452.28 [Kbytes/sec] received
    
    Connection Times (ms)
                  min  mean[+/-sd] median   max
    Connect:        0    0   2.5      0      45
    Processing:     2    9   1.6      9      46
    Waiting:        0    9   1.6      9      25
    Total:          2    9   3.2      9      58
    
    Percentage of the requests served within a certain time (ms)
    

    我尝试减少进程测试:

    • 当减少到 5 个进程时达到最高性能
    [[email protected]]$ ps -ef | grep mix.php
    nobody   24946     1  0 20:51 ?        00:00:15 /usr/local/php-7.3.12/bin/php mix/bin/mix.php web -r -d
    nobody   24963     1  0 20:51 ?        00:00:15 /usr/local/php-7.3.12/bin/php mix/bin/mix.php web -r -d
    nobody   24981     1  0 20:51 ?        00:00:15 /usr/local/php-7.3.12/bin/php mix/bin/mix.php web -r -d
    nobody   27471     1 22 21:35 ?        00:00:05 /usr/local/php-7.3.12/bin/php mix/bin/mix.php web -r -d
    nobody   27522     1 18 21:35 ?        00:00:03 /usr/local/php-7.3.12/bin/php mix/bin/mix.php web -r -d
    
    • 测试:多跑几次,基本稳定在 114070.87 左右,比 12 个进程的时候还高一点,证明再多开进程已经无法提升性能了,12 线程的 CPU 为何会这样呢?
    [[email protected]~]$ ab -n 100000 -c 1000 -k http://127.0.0.1:9501/
    This is ApacheBench, Version 2.3 <$Revision: 1430300 $>
    Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
    Licensed to The Apache Software Foundation, http://www.apache.org/
    
    Benchmarking 127.0.0.1 (be patient)
    
    Server Software:        swoole-http-server
    Server Hostname:        127.0.0.1
    Server Port:            9501
    
    Document Path:          /
    Document Length:        13 bytes
    
    Concurrency Level:      1000
    Time taken for tests:   0.877 seconds
    Complete requests:      100000
    Failed requests:        0
    Write errors:           0
    Keep-Alive requests:    100000
    Total transferred:      18100000 bytes
    HTML transferred:       1300000 bytes
    Requests per second:    114070.87 [#/sec] (mean)
    Time per request:       8.766 [ms] (mean)
    Time per request:       0.009 [ms] (mean, across all concurrent requests)
    Transfer rate:          20162.92 [Kbytes/sec] received
    
    Connection Times (ms)
                  min  mean[+/-sd] median   max
    Connect:        0    0   2.0      0      33
    Processing:     0    8   3.0      8      33
    Waiting:        0    8   3.0      8      24
    Total:          0    9   3.7      8      43
    
    Percentage of the requests served within a certain time (ms)
    

    Beego V1.12.1

    • 代码:
    package main
    
    import (
        "fmt"
        "net/http"
        "runtime"
    )
    
    func main() {
    
        http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
            writer.Write([]byte("hello, world!"))
        })
        err := http.ListenAndServe(":9999", nil)
        if err != nil{
            fmt.Println(err)
        }
    
    }
    
    • 测试:多跑几次,基本稳定在 107428.35 左右,与 Mix 非常接近。
    [[email protected]~]$ ab -n 100000 -c 1000 -k http://127.0.0.1:8989/index
    This is ApacheBench, Version 2.3 <$Revision: 1430300 $>
    Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
    Licensed to The Apache Software Foundation, http://www.apache.org/
    
    Benchmarking 127.0.0.1 (be patient)
    
    Server Software:        beegoServer:1.12.1
    Server Hostname:        127.0.0.1
    Server Port:            8989
    
    Document Path:          /index
    Document Length:        13 bytes
    
    Concurrency Level:      1000
    Time taken for tests:   0.931 seconds
    Complete requests:      100000
    Failed requests:        0
    Write errors:           0
    Keep-Alive requests:    100000
    Total transferred:      18200000 bytes
    HTML transferred:       1300000 bytes
    Requests per second:    107428.35 [#/sec] (mean)
    Time per request:       9.309 [ms] (mean)
    Time per request:       0.009 [ms] (mean, across all concurrent requests)
    Transfer rate:          19093.71 [Kbytes/sec] received
    
    Connection Times (ms)
                  min  mean[+/-sd] median   max
    Connect:        0    0   2.4      0      45
    Processing:     0    9   2.4      9      52
    Waiting:        0    9   2.4      9      52
    Total:          0    9   3.4      9      57
    
    Percentage of the requests served within a certain time (ms)
    

    PHP 7.3.12 + Swoole 4.4.14 二次测试

    上面减少到 5 个进程依然可以达到 12 进程的性能,我猜测可能是 ab -c 1000 只能达到 12w 左右的并发,也就是说没有打满,需要降低使用的线程数来测试,我们采用 2 个线程重新测试一下。

    • 先把测试进程减少到 2 个
    [[email protected]]$ ps -ef | grep test.php
    nobody    2200     1  0 7 月 22 ?       00:00:16 /usr/local/php-7.3.12/bin/php test.php
    nobody    9600     1  0 10:30 ?        00:00:00 /usr/local/php-7.3.12/bin/php test.php
    
    • 测试:多跑几次,基本稳定在 136426.58 左右
    [[email protected]~]$ ab -n 100000 -c 1000 -k http://127.0.0.1:8888/
    This is ApacheBench, Version 2.3 <$Revision: 1430300 $>
    Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
    Licensed to The Apache Software Foundation, http://www.apache.org/
    
    Benchmarking 127.0.0.1 (be patient)
    
    Server Software:        swoole-http-server
    Server Hostname:        127.0.0.1
    Server Port:            8888
    
    Document Path:          /
    Document Length:        13 bytes
    
    Concurrency Level:      1000
    Time taken for tests:   0.733 seconds
    Complete requests:      100000
    Failed requests:        0
    Write errors:           0
    Keep-Alive requests:    100000
    Total transferred:      16600000 bytes
    HTML transferred:       1300000 bytes
    Requests per second:    136426.58 [#/sec] (mean)
    Time per request:       7.330 [ms] (mean)
    Time per request:       0.007 [ms] (mean, across all concurrent requests)
    Transfer rate:          22116.03 [Kbytes/sec] received
    
    Connection Times (ms)
                  min  mean[+/-sd] median   max
    Connect:        0    0   2.2      0      43
    Processing:     2    7   1.7      6      43
    Waiting:        0    7   1.7      6      19
    Total:          2    7   2.9      6      53
    
    Percentage of the requests served within a certain time (ms)
    

    Go 1.13.4 二次测试

    • 代码:修改为 2 个线程
    package main
    
    import (
        "fmt"
        "net/http"
        "runtime"
    )
    
    func main() {
    
        runtime.GOMAXPROCS(2) // 限制使用线程数
    
        http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
            writer.Write([]byte("hello, world!"))
        })
        err := http.ListenAndServe(":9999", nil)
        if err != nil{
            fmt.Println(err)
        }
    
    }
    

    测试:多跑几次,基本稳定在 106834.75 左右,比 Swoole 性能低了 21.7%,证明 Swoole 确实性能是高于 Go 的 net 库。

    [[email protected]~]$ ab -n 100000 -c 1000 -k http://127.0.0.1:9999/
    This is ApacheBench, Version 2.3 <$Revision: 1430300 $>
    Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
    Licensed to The Apache Software Foundation, http://www.apache.org/
    
    Benchmarking 127.0.0.1 (be patient)
    
    Server Software:
    Server Hostname:        127.0.0.1
    Server Port:            9999
    
    Document Path:          /
    Document Length:        13 bytes
    
    Concurrency Level:      1000
    Time taken for tests:   0.936 seconds
    Complete requests:      100000
    Failed requests:        0
    Write errors:           0
    Keep-Alive requests:    100000
    Total transferred:      15400000 bytes
    HTML transferred:       1300000 bytes
    Requests per second:    106834.75 [#/sec] (mean)
    Time per request:       9.360 [ms] (mean)
    Time per request:       0.009 [ms] (mean, across all concurrent requests)
    Transfer rate:          16066.95 [Kbytes/sec] received
    
    Connection Times (ms)
                  min  mean[+/-sd] median   max
    Connect:        0    0   1.5      0      21
    Processing:     0    9   1.9      9      21
    Waiting:        0    9   1.9      9      17
    Total:          0    9   2.3      9      30
    
    Percentage of the requests served within a certain time (ms)
    

    MixPHP V2.2 二次测试

    • 先把测试进程减少到 2 个
    [[email protected]]$ ps -ef | grep mix.php
    nobody    7482     1  2 10:27 ?        00:00:05 /usr/local/php-7.3.12/bin/php mix/bin/mix.php web -r -d
    nobody   27522     1  0 7 月 22 ?       00:00:35 /usr/local/php-7.3.12/bin/php mix/bin/mix.php web -r -d
    
    • 测试:多跑几次,基本稳定在 53856.21 左右,果然,按这个数据分析,之前 12 进程测试的数据不合理,因为 ab -c 1000 没有将 CPU 性能打满。
    [[email protected]~]$ ab -n 100000 -c 1000 -k http://127.0.0.1:9501/
    This is ApacheBench, Version 2.3 <$Revision: 1430300 $>
    Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
    Licensed to The Apache Software Foundation, http://www.apache.org/
    
    Benchmarking 127.0.0.1 (be patient)
    
    Server Software:        swoole-http-server
    Server Hostname:        127.0.0.1
    Server Port:            9501
    
    Document Path:          /
    Document Length:        13 bytes
    
    Concurrency Level:      1000
    Time taken for tests:   1.857 seconds
    Complete requests:      100000
    Failed requests:        0
    Write errors:           0
    Keep-Alive requests:    100000
    Total transferred:      18100000 bytes
    HTML transferred:       1300000 bytes
    Requests per second:    53856.21 [#/sec] (mean)
    Time per request:       18.568 [ms] (mean)
    Time per request:       0.019 [ms] (mean, across all concurrent requests)
    Transfer rate:          9519.51 [Kbytes/sec] received
    
    Connection Times (ms)
                  min  mean[+/-sd] median   max
    Connect:        0    0   2.3      0      45
    Processing:     0   18   5.5     17      46
    Waiting:        0   18   5.5     17      38
    Total:          0   18   5.6     17      55
    
    Percentage of the requests served within a certain time (ms)
    

    Beego V1.12.1

    • 代码:同样我们限制使用 2 个线程
    package main
    
    import (
        "github.com/astaxie/beego"
        _ "hello/routers"
        "runtime"
    )
    
    type IndexController struct {
        beego.Controller
    }
    
    func (c *IndexController) Index() {
        c.Ctx.Output.Body([]byte("hello, world!"))
    }
    
    func main() {
    
        runtime.GOMAXPROCS(2) // 限制使用线程数
    
        beego.Router("/index", &IndexController{},"*:Index")
    
        beego.Run()
    
    }
    
    • 测试:多跑几次,基本稳定在 54547.49 左右,与 Mix 非常接近。
    [[email protected]~]$ ab -n 100000 -c 1000 -k http://127.0.0.1:8989/index
    This is ApacheBench, Version 2.3 <$Revision: 1430300 $>
    Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
    Licensed to The Apache Software Foundation, http://www.apache.org/
    
    Benchmarking 127.0.0.1 (be patient)
    
    Server Software:        beegoServer:1.12.1
    Server Hostname:        127.0.0.1
    Server Port:            8989
    
    Document Path:          /index
    Document Length:        13 bytes
    
    Concurrency Level:      1000
    Time taken for tests:   1.833 seconds
    Complete requests:      100000
    Failed requests:        0
    Write errors:           0
    Keep-Alive requests:    100000
    Total transferred:      18200000 bytes
    HTML transferred:       1300000 bytes
    Requests per second:    54547.49 [#/sec] (mean)
    Time per request:       18.333 [ms] (mean)
    Time per request:       0.018 [ms] (mean, across all concurrent requests)
    Transfer rate:          9694.96 [Kbytes/sec] received
    
    Connection Times (ms)
                  min  mean[+/-sd] median   max
    Connect:        0    0   1.9      0      31
    Processing:     0   18   6.3     19      40
    Waiting:        0   18   6.3     19      40
    Total:          0   18   6.3     19      41
    
    Percentage of the requests served within a certain time (ms)
    

    总结一下

    • 第一次测试:由于 ab -c 1000 测试的性能没有把 CPU 打满,导致测试结果不公正,应该很多人会忽略这个问题,认为自己的框架性能很高,其实是没有打满。

    | 语言 /框架 | 进 /线程数 |数值 |
    | PHP 7.3.12 + Swoole 4.4.14 | 12 | 127441.95 |
    | Go 1.13.4 | 1 <12 线程> | 121575.23 |
    | PHP 7.3.12 + Swoole 4.4.14 + MixPHP 2.2 | 12 | 110050.47 |
    | Go 1.13.4 + Beego 1.12.1 | 12 | 107428.35 |

    • 第二次测试:采用 2 线程测试比较公正,能打满 CPU,这样出来的结果才是真实结果,Swoole 比 Go 性能高 21.7% (毕竟是 C 写的),Mix 比 Swoole 原生降低了 60.5% 的性能,而 Mix 大概是 Go 原生一半的性能,与 Beego 性能齐平。

    | 语言 /框架 | 进 /线程数 |数值 |
    | PHP 7.3.12 + Swoole 4.4.14 | 2 | 136426.58 |
    | Go 1.13.4 | 1 <2 线程> | 106834.75 |
    | PHP 7.3.12 + Swoole 4.4.14 + MixPHP 2.2 | 2 | 53856.21 |
    | Go 1.13.4 + Beego 1.12.1 | 2 | 54547.49 |

    第 1 条附言  ·  58 天前
    53 条回复    2020-07-28 15:23:28 +08:00
    onanying
        1
    onanying   58 天前
    v2ex 只能发送 20000 个字符,也是醉了,只能删除一些内容
    loading
        3
    loading   58 天前
    一个结论:beego 性能差,doge.
    onanying
        4
    onanying   58 天前
    @bazingaterry fasthttp 肯定更强,但是这里的表达的观点的是 PHP 没那么弱 (在 IO 方面)
    blless
        5
    blless   58 天前 via Android   ❤️ 1
    helloworld 有啥用,整点正常玩意啊,来个最简单的 curd 也成啊,然后就知道所谓的动态语言跑 benchmark 都什么德性了
    onanying
        6
    onanying   58 天前
    @blless 不要轻易下结论,如果性能趋同如何?我打赌 10 块,Mix 一样拥有连接池,协程特性,既然你提了,我费力今天写一个 db 查询的。
    alexkkaa
        7
    alexkkaa   58 天前 via Android   ❤️ 1
    这种测试完全就是搞笑,就跟一个 hello world 说明一个语言好坏一样。go 是完全异步的,swoole 之类的只是这个库本身异步,巨量的第三方库甚至 php 自带的标准库很多都废了。类似 python 的 gevent 来个 monkey patch 这种手段也只是治标不治本 谁知道什么地方会有坑等着你。go 第三方库就就不存在这个问题因为人家是语言级的异步。第三方库就不存在这个问题。 要不然为什么 c#用了 async 后标准库里要整那么多 async 开头的方法
    virusdefender
        8
    virusdefender   58 天前
    ab 和 server 同一台机器可能影响结果,建议分开,另外现在一般都用 wrk 了吧
    onanying
        9
    onanying   58 天前
    @alexkkaa 你这种喷生态的,还算是喷的有点道理,喷查询性能的那是真外行
    onanying
        10
    onanying   58 天前
    @alexkkaa 我开发了 20 几个库处理这些问题,常用的 mysql + redis 么有问题,基于 guzzle 开发的库也没有问题,只能说常用第三方的生态都被改造支持异步了,冷门一些的就确实支持不太好。
    alexkkaa
        11
    alexkkaa   58 天前 via Android
    @onanying 这个得标准库支持才有意义,像.net 标准库里增加了很多异步方法,相应的社区第三方库也会使用这些自带的方法。 标准库不支持生态就起不来
    onanying
        12
    onanying   58 天前
    @alexkkaa 还有一点和 py c# 不同的是 php composer 的包都还能用(但是不支持异步了,在调用的那一段时间,但是执行结果完全不受影响,只是影响整体并发性能),这与 py3 和 c# 的生态不兼容的问题完全不同。
    onanying
        13
    onanying   58 天前
    @alexkkaa 所以说这个并不会适合普罗大众,但是有能力的团队都能 hold 住。当然方案有很多种比如我正在开发的 mix-go
    alexkkaa
        14
    alexkkaa   58 天前 via Android
    @onanying 但是有能力的团队为什么不直接上 go 呢,这不是隔靴搔痒吗
    alexkkaa
        15
    alexkkaa   58 天前 via Android
    我不是抬杠只是被这类坑过 发发感慨 哈
    onanying
        16
    onanying   58 天前
    @virusdefender 同样的环境,即便你说的有道理,影响的结果不会很大,这个是多次测试的均值。并且每次执行数值差异非常小。这台测试机器也没有做其他用途。
    onanying
        17
    onanying   58 天前
    @alexkkaa 20000+ rmb 的 php (同时会 go) 30000+ rmb 的 go (php 很烂) 你自己算吧,有了框架 15000+ 的 php 都能写。 同时 mix-go 和 mix-php 用法与设计架构完全一样,15000+ 的 php 同时还能写 go 。你自己算算这个账单吧。
    dvaknheo
        18
    dvaknheo   58 天前
    @onanying 所以,看见没,去学 go 啊,同学们,学 PHP 没钱途啊!
    blless
        19
    blless   58 天前   ❤️ 2
    @onanying 6# 你写呗 ,到时候贴个付款码就行 我跟了。很多人还是一厢情愿认为 IO 密集跟计算能力关系不大,我之前在公司内部也写过框架。除了网络 IO 以外,消耗大的还有数据序列化跟反序列化这一步,数据量越大越明显,甚至很有可能大量 CPU 都消耗在这个步骤。就光加一个序列化我估计 php,python 之流的 benchmark 就直接掉一个档次。
    guanhui07
        20
    guanhui07   58 天前
    @blless 后端业务常用的就 mysql redis 还有 curl 文件操作等 ,swoole4 已经完美支持了 同步写法,异步执行,swoole 也有了协程 ,常驻内存+协程,确实性能可以媲美 golang 了
    agui2200
        21
    agui2200   58 天前
    @blless 别说这个了,直接上个 RSA,php 就得贴地板,以前测试过,这块运算效率大概 java 是 php 的 X 倍吧...现在低一点,但还是快 X*50%倍吧最少?
    agui2200
        22
    agui2200   58 天前
    再补一刀,有个事情就想不明了,swoole 都学会了,go 学不会?
    dvaknheo
        23
    dvaknheo   58 天前
    @guanhui07
    假设有这么个第三方库的方法。Good Luck.

    public function getConfigsCached()
    {
    static $configs;
    if (!isset($configs)) {
    $configs = $this->getConfigsByDatabase();
    }
    return $configs;
    }

    复杂一点是 getUserCached($id); 我就不写了。
    也就是 @alexkkaa 说的巨量的第三方库甚至 php 自带的标准库很多都废了
    mitu9527
        24
    mitu9527   58 天前
    整天搞语言之争、性能之争,你们累不累?是有多自卑,还是虚荣心这么强?

    也难怪国外程序员嘲笑国内程序员菜,总想站在巨人的肩膀上,然后天天换肩膀,不菜就怪了。

    13 年到 18 年国内互联网行业大跃进,浮夸之风盛行,各种对比(语言、性能等等)和名头(大数据、高并发、架构师等等)就都来了。19 年开始经济形势下滑了,而且未来几年也大概率继续下滑,你们还没冷静下来么?

    风口过了,留下了一群惊慌失措的人在争吵。
    alexkkaa
        25
    alexkkaa   58 天前 via Android   ❤️ 2
    @mitu9527 要是没有争辩没有不满意技术怎么进步? 新技术的出现不就是因为不满意旧技术吗? 至于你说的那些个 ppt 对比这个大多是 kpi 或者说任务导向的。 没有对 java 的不满,哪来的它的那些亲儿子? 没有对 dotnet 的不满哪来的 dotnet core ?没有对 c++的不满哪来的 rust? 没有对跨平台的不满哪来的 flutter?
    技术的进步不仅提高了生产效率还缩减了生产成本。我们的项目原先需要十多台高配服务器,换了技术只需要三台就够了。每个月节省上万块,不香吗? 而且开发部署更高效流畅
    hronro
        26
    hronro   58 天前 via iPhone
    直接在 Tech Empower 上看测试结果就好了,没必要自己费力写测试
    https://www.techempower.com/benchmarks/
    dvaknheo
        27
    dvaknheo   58 天前
    @mitu9527 三哥程序员不一定比中国程序员强哦。只是中国程序员不会和外国程序员沟通而已。 基于 swoole 的 php 框架。 哪个老外可以和 mixphp 叫板的?
    mitu9527
        28
    mitu9527   58 天前
    @alexkkaa 你看看你的回复,涵盖了多少种争论了,你是有多关注这些争论的话题啊?你好好争,我不拦你。
    sagaxu
        29
    sagaxu   58 天前 via Android   ❤️ 1
    go 框架是 go 写的,swoole 是 C 写的,整个测试中大部分逻辑是框架完成的,本质是 Go vs C 。这类 micro benchmark,说是框架加配置文件也不为过,并不能体现真实应用的性能。

    随着业务逻辑代码的膨胀,语言本身的性能劣势慢慢凸显,这才真正开始考验性能。

    对于一般公司,比性能更重要的是生态,Swoole 生态一直没法跟 Go 相提并论。不过随着大家集中到 hyperf 之后,这方面差距也在慢慢缩小。
    huiyifyj
        30
    huiyifyj   58 天前
    着重现实,现在 php 的岗位越来越少了,go 倒是变多,很多公司 php 开始往 go 重构了。
    即使 php 比 go 性能高那么一丢丢,也不是选 php 的关键吧,那么在意性能,rust 框架不更好?
    roundgis
        31
    roundgis   58 天前   ❤️ 1
    動態語言如果在框架跑分上勝過 go

    通常是因為這些框架是用 c 寫的

    最後演變為 c vs go

    Go 從來都沒有宣稱快過 C
    Varobjs
        32
    Varobjs   58 天前 via Android
    @sagaxu 确实啊
    很多项目,优化优化里面的慢查询带来的提升远大于语言的性能提升
    paoqi2048
        33
    paoqi2048   58 天前
    楼上太孝顺了
    shanghai1998
        34
    shanghai1998   58 天前
    php 本身性能不差,楼主可以测试一个数据库 select,这个是瓶颈
    ajaxfunction
        35
    ajaxfunction   58 天前   ❤️ 2
    你没测的时候,说性能不行,你测了又说生态不行,之后还会说查询 db 不行,接着还会说序列化不行, 到最后又说扩展是 C 写的是 C 厉害, 总之动态语言就是不行
    ben1024
        36
    ben1024   58 天前
    带上有色眼镜看啥都不行,PHP 的后力薄弱,前期使用很舒服。
    swoole 说是要进行阉割并入 PHP,这个到是期待
    dbskcnc
        37
    dbskcnc   58 天前
    最终还是业务,满足了业务谁管你什么语言,动态语言谈性能显然不太合适,不过一般情况下其实也都能凑合就是了,绝大部分的系统的 qps 就那点,用哪个好像差别也还没有那么大,但是上限是不同的
    barbery
        38
    barbery   58 天前
    之前做了一款游戏,后端用的也是 swoole 的框架,不得不说,swoole 的高性能生态还有待完善,很多第三方包都是基于 fpm 的,但是整体高性能趋势是向好的,坚定看好 swoole 这个方向
    feelinglucky
        39
    feelinglucky   58 天前
    @onanying “这里的表达的观点的是 PHP 没那么弱”,感觉已经预设立场的测试中立性存疑
    luozic
        40
    luozic   58 天前 via iPhone
    跑这种为啥不去试试几个典型的 benchmark 库? 可以和 c# Java kotlin 比较比较,反正这个从来没说比 c 快
    onanying
        41
    onanying   58 天前
    @blless 我写了新的测试,是数据库+序列化,测试结果确实是 beego 性能更好,愿赌服输,你给一下付款码吧,测试链接: https://www.v2ex.com/t/693083
    chenqh
        42
    chenqh   58 天前
    @barbery 你这话说的,我都想学 php 了,哎
    wangbenjun5
        43
    wangbenjun5   58 天前
    一句话,用 swoole 还不如直接用 go,不解释
    lowe
        44
    lowe   58 天前
    go 的鲁棒性不是 swoole 能比的
    drackzy
        45
    drackzy   58 天前
    go 国内大厂基本都用 gin
    meshell
        46
    meshell   58 天前
    @drackzy 我发现 fiber 也很好用。性能方面还比 gin 好。
    p1gd0g
        47
    p1gd0g   58 天前
    俺们公司的实际情况就是 php 重构到 go,省了十多台服务器。
    但是欣赏 lz 的研究精神,多一些这种帖子肯定是件好事。
    blless
        48
    blless   58 天前 via Android
    @onanying #41 付款码就不必啦,楼主还肯花时间写挺不容易的。
    lxml
        49
    lxml   58 天前 via Android
    直觉上 PHP 无论怎么优化都干不过 Go,动态语言这方面确实不行,这个跟 PHP 优劣没关系,是开发效率运行效率编译效率权衡后的取舍,go 异步独步武林,这方面真没必要硬刚。
    onanying
        50
    onanying   58 天前
    @lxml 硬刚下来结果也还可以了,但是比我预想的要差一些,我预想是和 beego 差不多的,测试结果 mix 比 beego 数据库查询+序列化的综合性能要低 38.3%,附言那里有链接。
    www5070504
        51
    www5070504   57 天前
    这种方法能测出啥实质吗
    barbery
        52
    barbery   57 天前
    @chenqh 哈哈,语言只是工具,适合自己就好
    phpnote
        53
    phpnote   55 天前
    这难道不是 Golang vs C 么?
    关于   ·   FAQ   ·   API   ·   我们的愿景   ·   广告投放   ·   感谢   ·   实用小工具   ·   1665 人在线   最高记录 5168   ·     Select Language
    创意工作者们的社区
    World is powered by solitude
    VERSION: 3.9.8.5 · 40ms · UTC 17:05 · PVG 01:05 · LAX 10:05 · JFK 13:05
    ♥ Do have faith in what you're doing.