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

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

  •  2      
  •   onanying · 2020-07-25 10:07:35 +08:00 · 5753 次点击
    这是一个创建于 1581 天前的主题，其中的信息可能已经有所发展或是发生改变。

    好几年没有做过性能对比了，因为越来越觉得性能并没有那么的重要（相对于生态），今天有时间简单测试一下，因为 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();
    • 开启的进程
    [nobody@tmp]$ 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 左右。
    [nobody@~]$ 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)
    }

}
    • 开启的进程
    [nobody@~]$ ps -ef | grep gotest
nobody    4409  1859  0 20:25 pts/31   00:00:06 ./gotest_linux
    • 测试：多跑几次，基本稳定在 121575.23 左右，比 Swoole 稍微差点，但非常接近，PHP 是动态语言借助 Swoole 做到这个性能确实是非常夸张了。
    [nobody@~]$ 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 能跑多少。

    • 开启的进程
    [nobody@tmp]$ 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%，整个框架的代码只降低了这个比例，还是蛮可以的。
    [nobody@~]$ 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 个进程时达到最高性能
    [nobody@tmp]$ 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 为何会这样呢？
    [nobody@~]$ 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 非常接近。
    [nobody@~]$ 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 个
    [nobody@tmp]$ 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 左右
    [nobody@~]$ 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 库。

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

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

    复杂一点是 getUserCached($id); 我就不写了。
    也就是 @alexkkaa 说的巨量的第三方库甚至 php 自带的标准库很多都废了
    mitu9527
        24
    mitu9527  
       2020-07-25 11:28:43 +08:00
    整天搞语言之争、性能之争，你们累不累？是有多自卑，还是虚荣心这么强？

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

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

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

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

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

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

    最後演變為 c vs go

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